3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
33 * Search for Track numbers which will identify essence element KLV packets.
34 * Search for SourcePackage which define tracks which contains Track numbers.
35 * Material Package contains tracks with reference to SourcePackage tracks.
36 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37 * Assign Descriptors to correct Tracks.
39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40 * Metadata parsing resolves Strong References to objects.
42 * Simple demuxer, only OP1A supported and some files might not work at all.
43 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/timecode.h"
75 OPSONYOpt, /* FATE sample, violates the spec in places */
81 MXFPartitionType type;
82 uint64_t previous_partition;
85 int64_t this_partition;
86 int64_t essence_offset; ///< absolute offset of essence
87 int64_t essence_length;
89 int64_t header_byte_count;
90 int64_t index_byte_count;
92 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
97 enum MXFMetadataSetType type;
98 UID source_container_ul;
103 enum MXFMetadataSetType type;
104 UID source_package_uid;
105 UID data_definition_ul;
107 int64_t start_position;
109 } MXFStructuralComponent;
113 enum MXFMetadataSetType type;
114 UID data_definition_ul;
115 UID *structural_components_refs;
116 int structural_components_count;
123 enum MXFMetadataSetType type;
126 struct AVRational rate;
128 } MXFTimecodeComponent;
132 enum MXFMetadataSetType type;
133 UID input_segment_ref;
134 } MXFPulldownComponent;
138 enum MXFMetadataSetType type;
139 UID *structural_components_refs;
140 int structural_components_count;
146 enum MXFMetadataSetType type;
147 MXFSequence *sequence; /* mandatory, and only one */
150 uint8_t track_number[4];
151 AVRational edit_rate;
153 uint64_t sample_count;
154 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
159 enum MXFMetadataSetType type;
160 UID essence_container_ul;
161 UID essence_codec_ul;
162 AVRational sample_rate;
163 AVRational aspect_ratio;
165 int height; /* Field height, not frame height */
166 int frame_layout; /* See MXFFrameLayout enum */
172 int64_t duration; /* ContainerDuration optional property */
173 unsigned int component_depth;
174 unsigned int horiz_subsampling;
175 unsigned int vert_subsampling;
176 UID *sub_descriptors_refs;
177 int sub_descriptors_count;
181 enum AVPixelFormat pix_fmt;
186 enum MXFMetadataSetType type;
187 int edit_unit_byte_count;
190 AVRational index_edit_rate;
191 uint64_t index_start_position;
192 uint64_t index_duration;
193 int8_t *temporal_offset_entries;
195 uint64_t *stream_offset_entries;
196 int nb_index_entries;
197 } MXFIndexTableSegment;
201 enum MXFMetadataSetType type;
206 MXFDescriptor *descriptor; /* only one */
213 enum MXFMetadataSetType type;
216 /* decoded index table */
220 int nb_ptses; /* number of PTSes or total duration of index */
221 int64_t first_dts; /* DTS = EditUnit + first_dts */
222 int64_t *ptses; /* maps EditUnit -> PTS */
224 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
225 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
229 MXFPartition *partitions;
230 unsigned partitions_count;
234 MXFMetadataSet **metadata_sets;
235 int metadata_sets_count;
239 int local_tags_count;
240 uint64_t footer_partition;
241 KLVPacket current_klv_data;
242 int current_klv_index;
244 MXFPartition *current_partition;
245 int parsing_backward;
246 int64_t last_forward_tell;
247 int last_forward_partition;
248 int current_edit_unit;
250 MXFIndexTable *index_tables;
251 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
254 enum MXFWrappingScheme {
259 /* NOTE: klv_offset is not set (-1) for local keys */
260 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
264 MXFMetadataReadFunc *read;
266 enum MXFMetadataSetType type;
267 } MXFMetadataReadTableEntry;
269 static int mxf_read_close(AVFormatContext *s);
271 /* partial keys to match */
272 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
273 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
274 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
275 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
276 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
277 /* complete keys to match */
278 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
279 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
280 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
281 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
282 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
283 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
285 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
287 static void mxf_free_metadataset(MXFMetadataSet **ctx)
289 MXFIndexTableSegment *seg;
290 switch ((*ctx)->type) {
292 av_freep(&((MXFDescriptor *)*ctx)->extradata);
294 case MultipleDescriptor:
295 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
298 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
301 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
304 case MaterialPackage:
305 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
306 av_freep(&((MXFPackage *)*ctx)->name);
308 case IndexTableSegment:
309 seg = (MXFIndexTableSegment *)*ctx;
310 av_freep(&seg->temporal_offset_entries);
311 av_freep(&seg->flag_entries);
312 av_freep(&seg->stream_offset_entries);
319 static int64_t klv_decode_ber_length(AVIOContext *pb)
321 uint64_t size = avio_r8(pb);
322 if (size & 0x80) { /* long form */
323 int bytes_num = size & 0x7f;
324 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
326 return AVERROR_INVALIDDATA;
329 size = size << 8 | avio_r8(pb);
334 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
337 for (i = 0; i < size && !avio_feof(pb); i++) {
341 else if (b != key[i])
347 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
349 if (!mxf_read_sync(pb, mxf_klv_key, 4))
350 return AVERROR_INVALIDDATA;
351 klv->offset = avio_tell(pb) - 4;
352 memcpy(klv->key, mxf_klv_key, 4);
353 avio_read(pb, klv->key + 4, 12);
354 klv->length = klv_decode_ber_length(pb);
355 return klv->length == -1 ? -1 : 0;
358 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
362 for (i = 0; i < s->nb_streams; i++) {
363 MXFTrack *track = s->streams[i]->priv_data;
365 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
368 /* return 0 if only one stream, for OP Atom files with 0 as track number */
369 return s->nb_streams == 1 ? 0 : -1;
372 /* XXX: use AVBitStreamFilter */
373 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
375 const uint8_t *buf_ptr, *end_ptr;
379 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
380 return AVERROR_INVALIDDATA;
381 length = av_get_packet(pb, pkt, length);
384 data_ptr = pkt->data;
385 end_ptr = pkt->data + length;
386 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
387 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
388 for (i = 0; i < st->codec->channels; i++) {
389 uint32_t sample = bytestream_get_le32(&buf_ptr);
390 if (st->codec->bits_per_coded_sample == 24)
391 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
393 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
395 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
397 av_shrink_packet(pkt, data_ptr - pkt->data);
401 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
403 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
404 MXFContext *mxf = s->priv_data;
405 AVIOContext *pb = s->pb;
406 int64_t end = avio_tell(pb) + klv->length;
409 uint64_t plaintext_size;
414 if (!mxf->aesc && s->key && s->keylen == 16) {
415 mxf->aesc = av_aes_alloc();
417 return AVERROR(ENOMEM);
418 av_aes_init(mxf->aesc, s->key, 128, 1);
421 avio_skip(pb, klv_decode_ber_length(pb));
423 klv_decode_ber_length(pb);
424 plaintext_size = avio_rb64(pb);
426 klv_decode_ber_length(pb);
427 avio_read(pb, klv->key, 16);
428 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
429 return AVERROR_INVALIDDATA;
430 index = mxf_get_stream_index(s, klv);
432 return AVERROR_INVALIDDATA;
434 klv_decode_ber_length(pb);
435 orig_size = avio_rb64(pb);
436 if (orig_size < plaintext_size)
437 return AVERROR_INVALIDDATA;
439 size = klv_decode_ber_length(pb);
440 if (size < 32 || size - 32 < orig_size)
441 return AVERROR_INVALIDDATA;
442 avio_read(pb, ivec, 16);
443 avio_read(pb, tmpbuf, 16);
445 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
446 if (memcmp(tmpbuf, checkv, 16))
447 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
449 size = av_get_packet(pb, pkt, size);
452 else if (size < plaintext_size)
453 return AVERROR_INVALIDDATA;
454 size -= plaintext_size;
456 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
457 &pkt->data[plaintext_size], size >> 4, ivec, 1);
458 av_shrink_packet(pkt, orig_size);
459 pkt->stream_index = index;
460 avio_skip(pb, end - avio_tell(pb));
464 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
466 MXFContext *mxf = arg;
467 int item_num = avio_rb32(pb);
468 int item_len = avio_rb32(pb);
470 if (item_len != 18) {
471 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
472 return AVERROR_PATCHWELCOME;
474 if (item_num > 65536) {
475 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
476 return AVERROR_INVALIDDATA;
479 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
480 av_free(mxf->local_tags);
481 mxf->local_tags_count = 0;
482 mxf->local_tags = av_calloc(item_num, item_len);
483 if (!mxf->local_tags)
484 return AVERROR(ENOMEM);
485 mxf->local_tags_count = item_num;
486 avio_read(pb, mxf->local_tags, item_num*item_len);
490 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
492 MXFContext *mxf = arg;
493 MXFPartition *partition, *tmp_part;
495 uint64_t footer_partition;
496 uint32_t nb_essence_containers;
498 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
500 return AVERROR(ENOMEM);
501 mxf->partitions = tmp_part;
503 if (mxf->parsing_backward) {
504 /* insert the new partition pack in the middle
505 * this makes the entries in mxf->partitions sorted by offset */
506 memmove(&mxf->partitions[mxf->last_forward_partition+1],
507 &mxf->partitions[mxf->last_forward_partition],
508 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
509 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
511 mxf->last_forward_partition++;
512 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
515 memset(partition, 0, sizeof(*partition));
516 mxf->partitions_count++;
517 partition->pack_length = avio_tell(pb) - klv_offset + size;
518 partition->pack_ofs = klv_offset;
522 partition->type = Header;
525 partition->type = BodyPartition;
528 partition->type = Footer;
531 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
532 return AVERROR_INVALIDDATA;
535 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
536 partition->closed = partition->type == Footer || !(uid[14] & 1);
537 partition->complete = uid[14] > 2;
539 partition->kag_size = avio_rb32(pb);
540 partition->this_partition = avio_rb64(pb);
541 partition->previous_partition = avio_rb64(pb);
542 footer_partition = avio_rb64(pb);
543 partition->header_byte_count = avio_rb64(pb);
544 partition->index_byte_count = avio_rb64(pb);
545 partition->index_sid = avio_rb32(pb);
547 partition->body_sid = avio_rb32(pb);
548 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
549 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
550 return AVERROR_INVALIDDATA;
552 nb_essence_containers = avio_rb32(pb);
554 if (partition->this_partition &&
555 partition->previous_partition == partition->this_partition) {
556 av_log(mxf->fc, AV_LOG_ERROR,
557 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
558 partition->previous_partition);
559 /* override with the actual previous partition offset */
560 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
562 mxf->partitions + mxf->last_forward_partition - 2;
563 partition->previous_partition = prev->this_partition;
565 /* if no previous body partition are found point to the header
567 if (partition->previous_partition == partition->this_partition)
568 partition->previous_partition = 0;
569 av_log(mxf->fc, AV_LOG_ERROR,
570 "Overriding PreviousPartition with %"PRIx64"\n",
571 partition->previous_partition);
574 /* some files don'thave FooterPartition set in every partition */
575 if (footer_partition) {
576 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
577 av_log(mxf->fc, AV_LOG_ERROR,
578 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
579 mxf->footer_partition, footer_partition);
581 mxf->footer_partition = footer_partition;
586 "PartitionPack: ThisPartition = 0x%"PRIX64
587 ", PreviousPartition = 0x%"PRIX64", "
588 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
589 partition->this_partition,
590 partition->previous_partition, footer_partition,
591 partition->index_sid, partition->body_sid);
593 /* sanity check PreviousPartition if set */
594 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
595 if (partition->previous_partition &&
596 mxf->run_in + partition->previous_partition >= klv_offset) {
597 av_log(mxf->fc, AV_LOG_ERROR,
598 "PreviousPartition points to this partition or forward\n");
599 return AVERROR_INVALIDDATA;
602 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
603 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
604 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
605 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
606 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
607 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
608 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
609 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
610 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
611 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
612 else if (op[12] == 0x10) {
613 /* SMPTE 390m: "There shall be exactly one essence container"
614 * The following block deals with files that violate this, namely:
615 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
616 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
617 if (nb_essence_containers != 1) {
618 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
622 av_log(mxf->fc, AV_LOG_WARNING,
623 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
624 nb_essence_containers,
625 op == OP1a ? "OP1a" : "OPAtom");
631 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
635 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
636 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
637 partition->kag_size);
639 if (mxf->op == OPSONYOpt)
640 partition->kag_size = 512;
642 partition->kag_size = 1;
644 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
650 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
652 MXFMetadataSet **tmp;
654 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
656 return AVERROR(ENOMEM);
657 mxf->metadata_sets = tmp;
658 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
659 mxf->metadata_sets_count++;
663 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
665 MXFCryptoContext *cryptocontext = arg;
667 return AVERROR_INVALIDDATA;
668 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
669 avio_read(pb, cryptocontext->source_container_ul, 16);
673 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
675 MXFContext *mxf = arg;
678 if (mxf->packages_refs)
679 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
680 av_free(mxf->packages_refs);
681 mxf->packages_count = avio_rb32(pb);
682 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
683 if (!mxf->packages_refs)
684 return AVERROR(ENOMEM);
685 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
686 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
692 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
694 MXFStructuralComponent *source_clip = arg;
697 source_clip->duration = avio_rb64(pb);
700 source_clip->start_position = avio_rb64(pb);
703 /* UMID, only get last 16 bytes */
705 avio_read(pb, source_clip->source_package_uid, 16);
708 source_clip->source_track_id = avio_rb32(pb);
714 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
716 MXFTimecodeComponent *mxf_timecode = arg;
719 mxf_timecode->start_frame = avio_rb64(pb);
722 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
725 mxf_timecode->drop_frame = avio_r8(pb);
731 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
733 MXFPulldownComponent *mxf_pulldown = arg;
736 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
742 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
744 MXFTrack *track = arg;
747 track->track_id = avio_rb32(pb);
750 avio_read(pb, track->track_number, 4);
753 track->edit_rate.num = avio_rb32(pb);
754 track->edit_rate.den = avio_rb32(pb);
757 avio_read(pb, track->sequence_ref, 16);
763 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
765 MXFSequence *sequence = arg;
768 sequence->duration = avio_rb64(pb);
771 avio_read(pb, sequence->data_definition_ul, 16);
774 sequence->origin = avio_r8(pb);
777 sequence->structural_components_count = avio_rb32(pb);
778 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
779 if (!sequence->structural_components_refs) {
780 sequence->structural_components_count = 0;
781 return AVERROR(ENOMEM);
783 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
784 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
790 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
792 MXFEssenceGroup *essence_group = arg;
795 essence_group->duration = avio_rb64(pb);
798 essence_group->structural_components_count = avio_rb32(pb);
799 essence_group->structural_components_refs = av_calloc(essence_group->structural_components_count, sizeof(UID));
800 if (!essence_group->structural_components_refs) {
801 essence_group->structural_components_count = 0;
802 return AVERROR(ENOMEM);
804 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
805 avio_read(pb, (uint8_t *)essence_group->structural_components_refs, essence_group->structural_components_count * sizeof(UID));
811 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
817 return AVERROR(EINVAL);
819 buf_size = size + size / 2 + 1;
820 *str = av_malloc(buf_size);
822 return AVERROR(ENOMEM);
824 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
832 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
834 MXFPackage *package = arg;
837 package->tracks_count = avio_rb32(pb);
838 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
839 if (!package->tracks_refs)
840 return AVERROR(ENOMEM);
841 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
842 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
846 avio_read(pb, package->package_ul, 16);
847 avio_read(pb, package->package_uid, 16);
850 avio_read(pb, package->descriptor_ref, 16);
853 return mxf_read_utf16_string(pb, size, &package->name);
858 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
862 segment->nb_index_entries = avio_rb32(pb);
864 length = avio_rb32(pb);
866 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
867 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
868 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
869 av_freep(&segment->temporal_offset_entries);
870 av_freep(&segment->flag_entries);
871 return AVERROR(ENOMEM);
874 for (i = 0; i < segment->nb_index_entries; i++) {
875 segment->temporal_offset_entries[i] = avio_r8(pb);
876 avio_r8(pb); /* KeyFrameOffset */
877 segment->flag_entries[i] = avio_r8(pb);
878 segment->stream_offset_entries[i] = avio_rb64(pb);
879 avio_skip(pb, length - 11);
884 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
886 MXFIndexTableSegment *segment = arg;
889 segment->edit_unit_byte_count = avio_rb32(pb);
890 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
893 segment->index_sid = avio_rb32(pb);
894 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
897 segment->body_sid = avio_rb32(pb);
898 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
901 av_dlog(NULL, "IndexEntryArray found\n");
902 return mxf_read_index_entry_array(pb, segment);
904 segment->index_edit_rate.num = avio_rb32(pb);
905 segment->index_edit_rate.den = avio_rb32(pb);
906 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
907 segment->index_edit_rate.den);
910 segment->index_start_position = avio_rb64(pb);
911 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
914 segment->index_duration = avio_rb64(pb);
915 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
921 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
923 int code, value, ofs = 0;
924 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
929 av_dlog(NULL, "pixel layout: code %#x\n", code);
932 layout[ofs++] = code;
933 layout[ofs++] = value;
935 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
936 } while (code != 0); /* SMPTE 377M E.2.46 */
938 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
941 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
943 MXFDescriptor *descriptor = arg;
946 descriptor->sub_descriptors_count = avio_rb32(pb);
947 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
948 if (!descriptor->sub_descriptors_refs)
949 return AVERROR(ENOMEM);
950 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
951 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
953 case 0x3002: /* ContainerDuration */
954 descriptor->duration = avio_rb64(pb);
957 avio_read(pb, descriptor->essence_container_ul, 16);
960 descriptor->linked_track_id = avio_rb32(pb);
962 case 0x3201: /* PictureEssenceCoding */
963 avio_read(pb, descriptor->essence_codec_ul, 16);
966 descriptor->width = avio_rb32(pb);
969 descriptor->height = avio_rb32(pb);
972 descriptor->frame_layout = avio_r8(pb);
975 descriptor->aspect_ratio.num = avio_rb32(pb);
976 descriptor->aspect_ratio.den = avio_rb32(pb);
979 descriptor->field_dominance = avio_r8(pb);
982 descriptor->component_depth = avio_rb32(pb);
985 descriptor->horiz_subsampling = avio_rb32(pb);
988 descriptor->vert_subsampling = avio_rb32(pb);
991 descriptor->sample_rate.num = avio_rb32(pb);
992 descriptor->sample_rate.den = avio_rb32(pb);
994 case 0x3D06: /* SoundEssenceCompression */
995 avio_read(pb, descriptor->essence_codec_ul, 16);
998 descriptor->channels = avio_rb32(pb);
1001 descriptor->bits_per_sample = avio_rb32(pb);
1004 mxf_read_pixel_layout(pb, descriptor);
1007 /* Private uid used by SONY C0023S01.mxf */
1008 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1009 if (descriptor->extradata)
1010 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1011 av_free(descriptor->extradata);
1012 descriptor->extradata_size = 0;
1013 descriptor->extradata = av_malloc(size);
1014 if (!descriptor->extradata)
1015 return AVERROR(ENOMEM);
1016 descriptor->extradata_size = size;
1017 avio_read(pb, descriptor->extradata, size);
1025 * Match an uid independently of the version byte and up to len common bytes
1028 static int mxf_match_uid(const UID key, const UID uid, int len)
1031 for (i = 0; i < len; i++) {
1032 if (i != 7 && key[i] != uid[i])
1038 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1040 while (uls->uid[0]) {
1041 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1048 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1054 for (i = 0; i < mxf->metadata_sets_count; i++) {
1055 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1056 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1057 return mxf->metadata_sets[i];
1063 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1064 // video essence container uls
1065 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */
1066 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1067 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
1068 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1069 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1072 /* EC ULs for intra-only formats */
1073 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1074 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x00,0x00 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MXF-GC SMPTE D-10 Mappings */
1075 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1078 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1079 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1080 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x00,0x00 }, 14, AV_CODEC_ID_H264 }, /* H.264/MPEG-4 AVC Intra Profiles */
1081 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
1082 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1085 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1086 // sound essence container uls
1087 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */
1088 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
1089 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */
1090 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4F }, 14, AV_CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */
1091 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG2 AAC ADTS (legacy) */
1092 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1095 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1096 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1097 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1100 static const char* const mxf_data_essence_descriptor[] = {
1101 "vbi_vanc_smpte_436M",
1104 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1106 int i, j, nb_segments = 0;
1107 MXFIndexTableSegment **unsorted_segments;
1108 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1110 /* count number of segments, allocate arrays and copy unsorted segments */
1111 for (i = 0; i < mxf->metadata_sets_count; i++)
1112 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1116 return AVERROR_INVALIDDATA;
1118 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1119 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1120 av_freep(sorted_segments);
1121 av_free(unsorted_segments);
1122 return AVERROR(ENOMEM);
1125 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1126 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1127 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1129 *nb_sorted_segments = 0;
1131 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1132 for (i = 0; i < nb_segments; i++) {
1133 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1134 uint64_t best_index_duration = 0;
1136 for (j = 0; j < nb_segments; j++) {
1137 MXFIndexTableSegment *s = unsorted_segments[j];
1139 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1140 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1141 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1143 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1144 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1145 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1147 best_body_sid = s->body_sid;
1148 best_index_sid = s->index_sid;
1149 best_index_start = s->index_start_position;
1150 best_index_duration = s->index_duration;
1154 /* no suitable entry found -> we're done */
1158 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1159 last_body_sid = best_body_sid;
1160 last_index_sid = best_index_sid;
1161 last_index_start = best_index_start;
1164 av_free(unsorted_segments);
1170 * Computes the absolute file offset of the given essence container offset
1172 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1175 int64_t offset_in = offset; /* for logging */
1177 for (x = 0; x < mxf->partitions_count; x++) {
1178 MXFPartition *p = &mxf->partitions[x];
1180 if (p->body_sid != body_sid)
1183 if (offset < p->essence_length || !p->essence_length) {
1184 *offset_out = p->essence_offset + offset;
1188 offset -= p->essence_length;
1191 av_log(mxf->fc, AV_LOG_ERROR,
1192 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1193 offset_in, body_sid);
1195 return AVERROR_INVALIDDATA;
1199 * Returns the end position of the essence container with given BodySID, or zero if unknown
1201 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1206 for (x = 0; x < mxf->partitions_count; x++) {
1207 MXFPartition *p = &mxf->partitions[x];
1209 if (p->body_sid != body_sid)
1212 if (!p->essence_length)
1215 ret = p->essence_offset + p->essence_length;
1221 /* EditUnit -> absolute offset */
1222 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
1225 int64_t offset_temp = 0;
1227 for (i = 0; i < index_table->nb_segments; i++) {
1228 MXFIndexTableSegment *s = index_table->segments[i];
1230 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1232 if (edit_unit < s->index_start_position + s->index_duration) {
1233 int64_t index = edit_unit - s->index_start_position;
1235 if (s->edit_unit_byte_count)
1236 offset_temp += s->edit_unit_byte_count * index;
1237 else if (s->nb_index_entries) {
1238 if (s->nb_index_entries == 2 * s->index_duration + 1)
1239 index *= 2; /* Avid index */
1241 if (index < 0 || index >= s->nb_index_entries) {
1242 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1243 index_table->index_sid, s->index_start_position);
1244 return AVERROR_INVALIDDATA;
1247 offset_temp = s->stream_offset_entries[index];
1249 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1250 index_table->index_sid, s->index_start_position);
1251 return AVERROR_INVALIDDATA;
1255 *edit_unit_out = edit_unit;
1257 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1259 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1260 offset_temp += s->edit_unit_byte_count * s->index_duration;
1265 av_log(mxf->fc, AV_LOG_ERROR, "failed to map EditUnit %"PRId64" in IndexSID %i to an offset\n", edit_unit, index_table->index_sid);
1267 return AVERROR_INVALIDDATA;
1270 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1273 int8_t max_temporal_offset = -128;
1275 /* first compute how many entries we have */
1276 for (i = 0; i < index_table->nb_segments; i++) {
1277 MXFIndexTableSegment *s = index_table->segments[i];
1279 if (!s->nb_index_entries) {
1280 index_table->nb_ptses = 0;
1281 return 0; /* no TemporalOffsets */
1284 index_table->nb_ptses += s->index_duration;
1287 /* paranoid check */
1288 if (index_table->nb_ptses <= 0)
1291 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1292 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1293 av_freep(&index_table->ptses);
1294 return AVERROR(ENOMEM);
1297 /* we may have a few bad TemporalOffsets
1298 * make sure the corresponding PTSes don't have the bogus value 0 */
1299 for (x = 0; x < index_table->nb_ptses; x++)
1300 index_table->ptses[x] = AV_NOPTS_VALUE;
1314 * We want to transform it into this:
1325 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1326 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1327 * The latter makes DTS <= PTS.
1329 for (i = x = 0; i < index_table->nb_segments; i++) {
1330 MXFIndexTableSegment *s = index_table->segments[i];
1331 int index_delta = 1;
1332 int n = s->nb_index_entries;
1334 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1335 index_delta = 2; /* Avid index */
1336 /* ignore the last entry - it's the size of the essence container */
1340 for (j = 0; j < n; j += index_delta, x++) {
1341 int offset = s->temporal_offset_entries[j] / index_delta;
1342 int index = x + offset;
1344 if (x >= index_table->nb_ptses) {
1345 av_log(mxf->fc, AV_LOG_ERROR,
1346 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1347 s->nb_index_entries, s->index_duration);
1351 index_table->fake_index[x].timestamp = x;
1352 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1354 if (index < 0 || index >= index_table->nb_ptses) {
1355 av_log(mxf->fc, AV_LOG_ERROR,
1356 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1361 index_table->ptses[index] = x;
1362 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1366 index_table->first_dts = -max_temporal_offset;
1372 * Sorts and collects index table segments into index tables.
1373 * Also computes PTSes if possible.
1375 static int mxf_compute_index_tables(MXFContext *mxf)
1377 int i, j, k, ret, nb_sorted_segments;
1378 MXFIndexTableSegment **sorted_segments = NULL;
1380 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1381 nb_sorted_segments <= 0) {
1382 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1386 /* sanity check and count unique BodySIDs/IndexSIDs */
1387 for (i = 0; i < nb_sorted_segments; i++) {
1388 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1389 mxf->nb_index_tables++;
1390 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1391 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1392 ret = AVERROR_INVALIDDATA;
1393 goto finish_decoding_index;
1397 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1398 sizeof(*mxf->index_tables));
1399 if (!mxf->index_tables) {
1400 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1401 ret = AVERROR(ENOMEM);
1402 goto finish_decoding_index;
1405 /* distribute sorted segments to index tables */
1406 for (i = j = 0; i < nb_sorted_segments; i++) {
1407 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1412 mxf->index_tables[j].nb_segments++;
1415 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1416 MXFIndexTable *t = &mxf->index_tables[j];
1418 t->segments = av_mallocz_array(t->nb_segments,
1419 sizeof(*t->segments));
1422 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1423 " pointer array\n");
1424 ret = AVERROR(ENOMEM);
1425 goto finish_decoding_index;
1428 if (sorted_segments[i]->index_start_position)
1429 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1430 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1432 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1433 t->index_sid = sorted_segments[i]->index_sid;
1434 t->body_sid = sorted_segments[i]->body_sid;
1436 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1437 goto finish_decoding_index;
1439 /* fix zero IndexDurations */
1440 for (k = 0; k < t->nb_segments; k++) {
1441 if (t->segments[k]->index_duration)
1444 if (t->nb_segments > 1)
1445 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1448 if (mxf->fc->nb_streams <= 0) {
1449 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1453 /* assume the first stream's duration is reasonable
1454 * leave index_duration = 0 on further segments in case we have any (unlikely)
1456 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1462 finish_decoding_index:
1463 av_free(sorted_segments);
1467 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1469 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1470 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1471 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1472 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1475 static int mxf_uid_to_str(UID uid, char **str)
1479 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1481 return AVERROR(ENOMEM);
1482 for (i = 0; i < sizeof(UID); i++) {
1483 snprintf(p, 2 + 1, "%.2x", uid[i]);
1485 if (i == 3 || i == 5 || i == 7 || i == 9) {
1486 snprintf(p, 1 + 1, "-");
1493 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1497 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1499 return AVERROR(ENOMEM);
1500 snprintf(p, 2 + 1, "0x");
1502 for (i = 0; i < sizeof(UID); i++) {
1503 snprintf(p, 2 + 1, "%.2X", ul[i]);
1507 for (i = 0; i < sizeof(UID); i++) {
1508 snprintf(p, 2 + 1, "%.2X", uid[i]);
1514 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1520 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1522 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1526 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1528 char buf[AV_TIMECODE_STR_SIZE];
1529 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1534 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1536 MXFStructuralComponent *component = NULL;
1537 MXFPulldownComponent *pulldown = NULL;
1539 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1543 switch (component->type) {
1544 case TimecodeComponent:
1545 return (MXFTimecodeComponent*)component;
1546 case PulldownComponent: /* timcode component may be located on a pulldown component */
1547 pulldown = (MXFPulldownComponent*)component;
1548 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1555 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1557 MXFPackage *package = NULL;
1560 for (i = 0; i < mxf->packages_count; i++) {
1561 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1565 if (!memcmp(package->package_uid, package_uid, 16))
1571 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1573 MXFDescriptor *sub_descriptor = NULL;
1579 if (descriptor->type == MultipleDescriptor) {
1580 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1581 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1583 if (!sub_descriptor) {
1584 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1587 if (sub_descriptor->linked_track_id == track_id) {
1588 return sub_descriptor;
1591 } else if (descriptor->type == Descriptor)
1597 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1599 MXFStructuralComponent *component = NULL;
1600 MXFPackage *package = NULL;
1601 MXFDescriptor *descriptor = NULL;
1604 if (!essence_group || !essence_group->structural_components_count)
1607 /* essence groups contains multiple representations of the same media,
1608 this return the first components with a valid Descriptor typically index 0 */
1609 for (i =0; i < essence_group->structural_components_count; i++){
1610 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1614 if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1617 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1624 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1626 MXFStructuralComponent *component = NULL;
1628 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1631 switch (component->type) {
1635 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1642 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1644 MXFPackage *physical_package = NULL;
1645 MXFTrack *physical_track = NULL;
1646 MXFStructuralComponent *sourceclip = NULL;
1647 MXFTimecodeComponent *mxf_tc = NULL;
1651 int64_t start_position;
1653 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1654 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1658 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1661 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1663 /* the name of physical source package is name of the reel or tape */
1664 if (physical_package->name && physical_package->name[0])
1665 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1667 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1668 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1670 for (j = 0; j < physical_package->tracks_count; j++) {
1671 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1672 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1676 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1677 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1681 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1682 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1685 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1686 /* scale sourceclip start_position to match physical track edit rate */
1687 start_position = av_rescale_q(sourceclip->start_position,
1688 physical_track->edit_rate,
1689 source_track->edit_rate);
1691 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1692 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1702 static int mxf_parse_structural_metadata(MXFContext *mxf)
1704 MXFPackage *material_package = NULL;
1707 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1708 /* TODO: handle multiple material packages (OP3x) */
1709 for (i = 0; i < mxf->packages_count; i++) {
1710 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1711 if (material_package) break;
1713 if (!material_package) {
1714 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1715 return AVERROR_INVALIDDATA;
1718 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1719 if (material_package->name && material_package->name[0])
1720 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1722 for (i = 0; i < material_package->tracks_count; i++) {
1723 MXFPackage *source_package = NULL;
1724 MXFTrack *material_track = NULL;
1725 MXFTrack *source_track = NULL;
1726 MXFTrack *temp_track = NULL;
1727 MXFDescriptor *descriptor = NULL;
1728 MXFStructuralComponent *component = NULL;
1729 MXFTimecodeComponent *mxf_tc = NULL;
1730 UID *essence_container_ul = NULL;
1731 const MXFCodecUL *codec_ul = NULL;
1732 const MXFCodecUL *container_ul = NULL;
1733 const MXFCodecUL *pix_fmt_ul = NULL;
1738 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1739 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1743 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1744 mxf_tc = (MXFTimecodeComponent*)component;
1745 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1746 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1747 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1751 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1752 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1756 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1757 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1761 mxf_tc = (MXFTimecodeComponent*)component;
1762 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1763 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1764 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1769 /* TODO: handle multiple source clips */
1770 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1771 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1775 source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1776 if (!source_package) {
1777 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1780 for (k = 0; k < source_package->tracks_count; k++) {
1781 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1782 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1783 ret = AVERROR_INVALIDDATA;
1786 if (temp_track->track_id == component->source_track_id) {
1787 source_track = temp_track;
1791 if (!source_track) {
1792 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1796 if (!source_track || !component)
1799 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1800 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1801 ret = AVERROR_INVALIDDATA;
1805 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1806 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1807 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1808 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1812 st = avformat_new_stream(mxf->fc, NULL);
1814 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1815 ret = AVERROR(ENOMEM);
1818 st->id = source_track->track_id;
1819 st->priv_data = source_track;
1821 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1822 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1824 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1825 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1826 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1827 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1829 source_track->original_duration = st->duration = component->duration;
1831 if (st->duration == -1)
1832 st->duration = AV_NOPTS_VALUE;
1833 st->start_time = component->start_position;
1834 if (material_track->edit_rate.num <= 0 ||
1835 material_track->edit_rate.den <= 0) {
1836 av_log(mxf->fc, AV_LOG_WARNING,
1837 "Invalid edit rate (%d/%d) found on stream #%d, "
1838 "defaulting to 25/1\n",
1839 material_track->edit_rate.num,
1840 material_track->edit_rate.den, st->index);
1841 material_track->edit_rate = (AVRational){25, 1};
1843 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1845 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1846 * the former is accessible via st->priv_data */
1847 source_track->edit_rate = material_track->edit_rate;
1849 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1850 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1851 st->codec->codec_type = codec_ul->id;
1854 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1857 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1858 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1859 essence_container_ul = &descriptor->essence_container_ul;
1860 /* HACK: replacing the original key with mxf_encrypted_essence_container
1861 * is not allowed according to s429-6, try to find correct information anyway */
1862 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1863 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1864 for (k = 0; k < mxf->metadata_sets_count; k++) {
1865 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1866 if (metadata->type == CryptoContext) {
1867 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1873 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1874 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1875 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1876 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1877 avcodec_get_name(st->codec->codec_id));
1878 for (k = 0; k < 16; k++) {
1879 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1880 descriptor->essence_codec_ul[k]);
1881 if (!(k+1 & 19) || k == 5)
1882 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1884 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1886 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
1887 if (source_package->name && source_package->name[0])
1888 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
1890 mxf_parse_physical_source_package(mxf, source_track, st);
1892 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1893 source_track->intra_only = mxf_is_intra_only(descriptor);
1894 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1895 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1896 st->codec->codec_id = container_ul->id;
1897 st->codec->width = descriptor->width;
1898 st->codec->height = descriptor->height; /* Field height, not frame height */
1899 switch (descriptor->frame_layout) {
1900 case SegmentedFrame:
1901 /* This one is a weird layout I don't fully understand. */
1902 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1905 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1908 /* Every other line is stored and needs to be duplicated. */
1909 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1910 break; /* The correct thing to do here is fall through, but by breaking we might be
1911 able to decode some streams at half the vertical resolution, rather than not al all.
1912 It's also for compatibility with the old behavior. */
1915 case SeparateFields:
1916 switch (descriptor->field_dominance) {
1918 st->codec->field_order = AV_FIELD_TT;
1921 st->codec->field_order = AV_FIELD_BB;
1924 avpriv_request_sample(mxf->fc,
1925 "Field dominance %d support",
1926 descriptor->field_dominance);
1927 case 0: // we already have many samples with field_dominance == unknown
1930 /* Turn field height into frame height. */
1931 st->codec->height *= 2;
1934 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1936 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1937 st->codec->pix_fmt = descriptor->pix_fmt;
1938 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1939 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1940 &descriptor->essence_codec_ul);
1941 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1942 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1943 /* support files created before RP224v10 by defaulting to UYVY422
1944 if subsampling is 4:2:2 and component depth is 8-bit */
1945 if (descriptor->horiz_subsampling == 2 &&
1946 descriptor->vert_subsampling == 1 &&
1947 descriptor->component_depth == 8) {
1948 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1953 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1954 if (material_track->sequence->origin) {
1955 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1957 if (source_track->sequence->origin) {
1958 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1960 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1961 st->display_aspect_ratio = descriptor->aspect_ratio;
1962 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1963 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1964 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1965 if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
1966 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1967 st->codec->channels = descriptor->channels;
1968 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1970 if (descriptor->sample_rate.den > 0) {
1971 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1972 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1974 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1975 "found for stream #%d, time base forced to 1/48000\n",
1976 descriptor->sample_rate.num, descriptor->sample_rate.den,
1978 avpriv_set_pts_info(st, 64, 1, 48000);
1981 /* if duration is set, rescale it from EditRate to SampleRate */
1982 if (st->duration != AV_NOPTS_VALUE)
1983 st->duration = av_rescale_q(st->duration,
1984 av_inv_q(material_track->edit_rate),
1987 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1988 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1989 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1990 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1991 else if (descriptor->bits_per_sample == 32)
1992 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1993 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1994 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1995 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1996 else if (descriptor->bits_per_sample == 32)
1997 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1998 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1999 st->need_parsing = AVSTREAM_PARSE_FULL;
2001 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2002 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2003 essence_container_ul)->id;
2004 if (codec_id >= 0 &&
2005 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2006 av_dict_set(&st->metadata, "data_type",
2007 mxf_data_essence_descriptor[codec_id], 0);
2010 if (descriptor->extradata) {
2011 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
2012 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
2014 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
2015 ret = ff_generate_avci_extradata(st);
2019 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2020 /* TODO: decode timestamps */
2021 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2030 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2032 struct tm time = { 0 };
2033 time.tm_year = (timestamp >> 48) - 1900;
2034 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2035 time.tm_mday = (timestamp >> 32 & 0xFF);
2036 time.tm_hour = (timestamp >> 24 & 0xFF);
2037 time.tm_min = (timestamp >> 16 & 0xFF);
2038 time.tm_sec = (timestamp >> 8 & 0xFF);
2040 /* msvcrt versions of strftime calls the invalid parameter handler
2041 * (aborting the process if one isn't set) if the parameters are out
2043 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2044 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2045 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2046 time.tm_min = av_clip(time.tm_min, 0, 59);
2047 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2049 *str = av_mallocz(32);
2051 return AVERROR(ENOMEM);
2052 if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2058 #define SET_STR_METADATA(pb, name, str) do { \
2059 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
2061 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2064 #define SET_UID_METADATA(pb, name, var, str) do { \
2065 avio_read(pb, var, 16); \
2066 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2068 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2071 #define SET_TS_METADATA(pb, name, var, str) do { \
2072 var = avio_rb64(pb); \
2073 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2075 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2078 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2080 MXFContext *mxf = arg;
2081 AVFormatContext *s = mxf->fc;
2088 SET_STR_METADATA(pb, "company_name", str);
2091 SET_STR_METADATA(pb, "product_name", str);
2094 SET_STR_METADATA(pb, "product_version", str);
2097 SET_UID_METADATA(pb, "product_uid", uid, str);
2100 SET_TS_METADATA(pb, "modification_date", ts, str);
2103 SET_STR_METADATA(pb, "application_platform", str);
2106 SET_UID_METADATA(pb, "generation_uid", uid, str);
2109 SET_UID_METADATA(pb, "uid", uid, str);
2115 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2117 MXFContext *mxf = arg;
2118 AVFormatContext *s = mxf->fc;
2122 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2123 SET_STR_METADATA(pb, "project_name", str);
2128 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2129 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2130 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2131 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2132 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2133 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2134 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2135 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2136 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2137 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2138 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2139 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2140 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2141 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2142 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2143 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2144 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2145 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2146 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2147 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2148 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2149 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x42,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Generic Sound */
2150 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2151 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2152 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
2153 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2154 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2155 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2156 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */
2157 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2158 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2159 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2160 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2161 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2162 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2163 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2164 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2167 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2170 case MultipleDescriptor:
2172 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2173 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2181 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2183 AVIOContext *pb = mxf->fc->pb;
2184 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2185 uint64_t klv_end = avio_tell(pb) + klv->length;
2188 return AVERROR(ENOMEM);
2189 mxf_metadataset_init(ctx, type);
2190 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2192 int tag = avio_rb16(pb);
2193 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2194 uint64_t next = avio_tell(pb) + size;
2197 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2198 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2199 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2202 if (tag > 0x7FFF) { /* dynamic tag */
2204 for (i = 0; i < mxf->local_tags_count; i++) {
2205 int local_tag = AV_RB16(mxf->local_tags+i*18);
2206 if (local_tag == tag) {
2207 memcpy(uid, mxf->local_tags+i*18+2, 16);
2208 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2209 PRINT_KEY(mxf->fc, "uid", uid);
2213 if (ctx_size && tag == 0x3C0A) {
2214 avio_read(pb, ctx->uid, 16);
2215 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2216 mxf_free_metadataset(&ctx);
2220 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2221 * it extending past the end of the KLV though (zzuf5.mxf). */
2222 if (avio_tell(pb) > klv_end) {
2225 mxf_free_metadataset(&ctx);
2228 av_log(mxf->fc, AV_LOG_ERROR,
2229 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2231 return AVERROR_INVALIDDATA;
2232 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2233 avio_seek(pb, next, SEEK_SET);
2235 if (ctx_size) ctx->type = type;
2236 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2240 * Matches any partition pack key, in other words:
2244 * @return non-zero if the key is a partition pack key, zero otherwise
2246 static int mxf_is_partition_pack_key(UID key)
2248 //NOTE: this is a little lax since it doesn't constraint key[14]
2249 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2250 key[13] >= 2 && key[13] <= 4;
2254 * Parses a metadata KLV
2255 * @return <0 on error, 0 otherwise
2257 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2258 int ctx_size, enum MXFMetadataSetType type)
2260 AVFormatContext *s = mxf->fc;
2262 if (klv.key[5] == 0x53) {
2263 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2265 uint64_t next = avio_tell(s->pb) + klv.length;
2266 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2268 /* only seek forward, else this can loop for a long time */
2269 if (avio_tell(s->pb) > next) {
2270 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2272 return AVERROR_INVALIDDATA;
2275 avio_seek(s->pb, next, SEEK_SET);
2278 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2285 * Seeks to the previous partition and parses it, if possible
2286 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2288 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2290 AVIOContext *pb = mxf->fc->pb;
2292 int64_t current_partition_ofs;
2295 if (!mxf->current_partition ||
2296 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2297 return 0; /* we've parsed all partitions */
2299 /* seek to previous partition */
2300 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2301 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2302 mxf->current_partition = NULL;
2304 av_dlog(mxf->fc, "seeking to previous partition\n");
2306 /* Make sure this is actually a PartitionPack, and if so parse it.
2309 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2310 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2314 if (!mxf_is_partition_pack_key(klv.key)) {
2315 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2316 return AVERROR_INVALIDDATA;
2319 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2320 * can point to just before the current partition, causing klv_read_packet()
2321 * to sync back up to it. See deadlock3.mxf
2323 if (klv.offset >= current_partition_ofs) {
2324 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2325 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2326 return AVERROR_INVALIDDATA;
2329 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2336 * Called when essence is encountered
2337 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2339 static int mxf_parse_handle_essence(MXFContext *mxf)
2341 AVIOContext *pb = mxf->fc->pb;
2344 if (mxf->parsing_backward) {
2345 return mxf_seek_to_previous_partition(mxf);
2347 if (!mxf->footer_partition) {
2348 av_dlog(mxf->fc, "no FooterPartition\n");
2352 av_dlog(mxf->fc, "seeking to FooterPartition\n");
2354 /* remember where we were so we don't end up seeking further back than this */
2355 mxf->last_forward_tell = avio_tell(pb);
2357 if (!pb->seekable) {
2358 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2362 /* seek to FooterPartition and parse backward */
2363 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2364 av_log(mxf->fc, AV_LOG_ERROR,
2365 "failed to seek to FooterPartition @ 0x%" PRIx64
2366 " (%"PRId64") - partial file?\n",
2367 mxf->run_in + mxf->footer_partition, ret);
2371 mxf->current_partition = NULL;
2372 mxf->parsing_backward = 1;
2379 * Called when the next partition or EOF is encountered
2380 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2382 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2384 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2388 * Figures out the proper offset and length of the essence container in each partition
2390 static void mxf_compute_essence_containers(MXFContext *mxf)
2394 /* everything is already correct */
2395 if (mxf->op == OPAtom)
2398 for (x = 0; x < mxf->partitions_count; x++) {
2399 MXFPartition *p = &mxf->partitions[x];
2402 continue; /* BodySID == 0 -> no essence */
2404 if (x >= mxf->partitions_count - 1)
2405 break; /* FooterPartition - can't compute length (and we don't need to) */
2407 /* essence container spans to the next partition */
2408 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2410 if (p->essence_length < 0) {
2411 /* next ThisPartition < essence_offset */
2412 p->essence_length = 0;
2413 av_log(mxf->fc, AV_LOG_ERROR,
2414 "partition %i: bad ThisPartition = %"PRIX64"\n",
2415 x+1, mxf->partitions[x+1].this_partition);
2420 static int64_t round_to_kag(int64_t position, int kag_size)
2422 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2423 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2424 int64_t ret = (position / kag_size) * kag_size;
2425 return ret == position ? ret : ret + kag_size;
2428 static int is_pcm(enum AVCodecID codec_id)
2430 /* we only care about "normal" PCM codecs until we get samples */
2431 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2435 * Deal with the case where for some audio atoms EditUnitByteCount is
2436 * very small (2, 4..). In those cases we should read more than one
2437 * sample per call to mxf_read_packet().
2439 static void mxf_handle_small_eubc(AVFormatContext *s)
2441 MXFContext *mxf = s->priv_data;
2443 /* assuming non-OPAtom == frame wrapped
2444 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2445 if (mxf->op != OPAtom)
2448 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2449 if (s->nb_streams != 1 ||
2450 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2451 !is_pcm(s->streams[0]->codec->codec_id) ||
2452 mxf->nb_index_tables != 1 ||
2453 mxf->index_tables[0].nb_segments != 1 ||
2454 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2457 /* arbitrarily default to 48 kHz PAL audio frame size */
2458 /* TODO: We could compute this from the ratio between the audio
2459 * and video edit rates for 48 kHz NTSC we could use the
2460 * 1802-1802-1802-1802-1801 pattern. */
2461 mxf->edit_units_per_packet = 1920;
2465 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2467 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2469 AVFormatContext *s = mxf->fc;
2470 AVStream *st = NULL;
2471 MXFIndexTableSegment *segment = NULL;
2472 MXFPartition *p = NULL;
2473 int essence_partition_count = 0;
2476 if (mxf->op != OPAtom)
2479 /* TODO: support raw video without a index if they exist */
2480 if (s->nb_streams != 1 || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(s->streams[0]->codec->codec_id))
2483 /* check if file already has a IndexTableSegment */
2484 for (i = 0; i < mxf->metadata_sets_count; i++) {
2485 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2489 /* find the essence partition */
2490 for (i = 0; i < mxf->partitions_count; i++) {
2491 /* BodySID == 0 -> no essence */
2492 if (!mxf->partitions[i].body_sid)
2495 p = &mxf->partitions[i];
2496 essence_partition_count++;
2499 /* only handle files with a single essence partition */
2500 if (essence_partition_count != 1)
2503 if (!(segment = av_mallocz(sizeof(*segment))))
2504 return AVERROR(ENOMEM);
2506 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2507 mxf_free_metadataset((MXFMetadataSet**)&segment);
2512 segment->type = IndexTableSegment;
2513 /* stream will be treated as small EditUnitByteCount */
2514 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
2515 segment->index_start_position = 0;
2516 segment->index_duration = s->streams[0]->duration;
2517 segment->index_sid = p->index_sid;
2518 segment->body_sid = p->body_sid;
2522 static void mxf_read_random_index_pack(AVFormatContext *s)
2524 MXFContext *mxf = s->priv_data;
2526 int64_t file_size, max_rip_length, min_rip_length;
2529 if (!s->pb->seekable)
2532 file_size = avio_size(s->pb);
2534 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2535 * The limit below assumes a file with nothing but partition packs and a RIP.
2536 * Before changing this, consider that a muxer may place each sample in its own partition.
2538 * 105 is the size of the smallest possible PartitionPack
2539 * 12 is the size of each RIP entry
2540 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2542 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2543 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2545 /* We're only interested in RIPs with at least two entries.. */
2546 min_rip_length = 16+1+24+4;
2548 /* See S377m section 11 */
2549 avio_seek(s->pb, file_size - 4, SEEK_SET);
2550 length = avio_rb32(s->pb);
2552 if (length < min_rip_length || length > max_rip_length)
2554 avio_seek(s->pb, file_size - length, SEEK_SET);
2555 if (klv_read_packet(&klv, s->pb) < 0 ||
2556 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2557 klv.length != length - 20)
2560 avio_skip(s->pb, klv.length - 12);
2561 mxf->footer_partition = avio_rb64(s->pb);
2564 if (mxf->run_in + mxf->footer_partition >= file_size) {
2565 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2566 mxf->footer_partition = 0;
2570 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2573 static int mxf_read_header(AVFormatContext *s)
2575 MXFContext *mxf = s->priv_data;
2577 int64_t essence_offset = 0;
2580 mxf->last_forward_tell = INT64_MAX;
2581 mxf->edit_units_per_packet = 1;
2583 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2584 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2585 return AVERROR_INVALIDDATA;
2587 avio_seek(s->pb, -14, SEEK_CUR);
2589 mxf->run_in = avio_tell(s->pb);
2591 mxf_read_random_index_pack(s);
2593 while (!avio_feof(s->pb)) {
2594 const MXFMetadataReadTableEntry *metadata;
2596 if (klv_read_packet(&klv, s->pb) < 0) {
2597 /* EOF - seek to previous partition or stop */
2598 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2604 PRINT_KEY(s, "read header", klv.key);
2605 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2606 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2607 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2608 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2609 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2611 if (!mxf->current_partition) {
2612 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2613 return AVERROR_INVALIDDATA;
2616 if (!mxf->current_partition->essence_offset) {
2617 /* for OP1a we compute essence_offset
2618 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2619 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2620 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2622 int64_t op1a_essence_offset =
2623 round_to_kag(mxf->current_partition->this_partition +
2624 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2625 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2626 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2628 if (mxf->op == OPAtom) {
2629 /* point essence_offset to the actual data
2630 * OPAtom has all the essence in one big KLV
2632 mxf->current_partition->essence_offset = avio_tell(s->pb);
2633 mxf->current_partition->essence_length = klv.length;
2635 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2636 mxf->current_partition->essence_offset = op1a_essence_offset;
2640 if (!essence_offset)
2641 essence_offset = klv.offset;
2643 /* seek to footer, previous partition or stop */
2644 if (mxf_parse_handle_essence(mxf) <= 0)
2647 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2648 /* next partition pack - keep going, seek to previous partition or stop */
2649 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2651 else if (mxf->parsing_backward)
2653 /* we're still parsing forward. proceed to parsing this partition pack */
2656 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2657 if (IS_KLV_KEY(klv.key, metadata->key)) {
2658 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2662 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2666 if (!metadata->read)
2667 avio_skip(s->pb, klv.length);
2669 /* FIXME avoid seek */
2670 if (!essence_offset) {
2671 av_log(s, AV_LOG_ERROR, "no essence\n");
2672 ret = AVERROR_INVALIDDATA;
2675 avio_seek(s->pb, essence_offset, SEEK_SET);
2677 mxf_compute_essence_containers(mxf);
2679 /* we need to do this before computing the index tables
2680 * to be able to fill in zero IndexDurations with st->duration */
2681 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2684 mxf_handle_missing_index_segment(mxf);
2685 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2688 if (mxf->nb_index_tables > 1) {
2689 /* TODO: look up which IndexSID to use via EssenceContainerData */
2690 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2691 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2692 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2693 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2694 ret = AVERROR_INVALIDDATA;
2698 mxf_handle_small_eubc(s);
2708 * Sets mxf->current_edit_unit based on what offset we're currently at.
2709 * @return next_ofs if OK, <0 on error
2711 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2713 int64_t last_ofs = -1, next_ofs = -1;
2714 MXFIndexTable *t = &mxf->index_tables[0];
2716 /* this is called from the OP1a demuxing logic, which means there
2717 * may be no index tables */
2718 if (mxf->nb_index_tables <= 0)
2721 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2722 while (mxf->current_edit_unit >= 0) {
2723 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2726 if (next_ofs <= last_ofs) {
2727 /* large next_ofs didn't change or current_edit_unit wrapped
2728 * around this fixes the infinite loop on zzuf3.mxf */
2729 av_log(mxf->fc, AV_LOG_ERROR,
2730 "next_ofs didn't change. not deriving packet timestamps\n");
2734 if (next_ofs > current_offset)
2737 last_ofs = next_ofs;
2738 mxf->current_edit_unit++;
2741 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2742 if (mxf->current_edit_unit < 0)
2748 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2749 uint64_t *sample_count)
2751 int i, total = 0, size = 0;
2752 AVStream *st = mxf->fc->streams[stream_index];
2753 MXFTrack *track = st->priv_data;
2754 AVRational time_base = av_inv_q(track->edit_rate);
2755 AVRational sample_rate = av_inv_q(st->time_base);
2756 const MXFSamplesPerFrame *spf = NULL;
2758 if ((sample_rate.num / sample_rate.den) == 48000)
2759 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2761 int remainder = (sample_rate.num * time_base.num) %
2762 (time_base.den * sample_rate.den);
2763 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2764 av_mul_q(sample_rate, time_base)));
2766 av_log(mxf->fc, AV_LOG_WARNING,
2767 "seeking detected on stream #%d with time base (%d/%d) and "
2768 "sample rate (%d/%d), audio pts won't be accurate.\n",
2769 stream_index, time_base.num, time_base.den,
2770 sample_rate.num, sample_rate.den);
2774 while (spf->samples_per_frame[size]) {
2775 total += spf->samples_per_frame[size];
2781 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2782 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2783 *sample_count += spf->samples_per_frame[i];
2789 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2792 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2793 int64_t bits_per_sample = codec->bits_per_coded_sample;
2795 if (!bits_per_sample)
2796 bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2798 pkt->pts = track->sample_count;
2800 if ( codec->channels <= 0
2801 || bits_per_sample <= 0
2802 || codec->channels * (int64_t)bits_per_sample < 8)
2803 return AVERROR(EINVAL);
2804 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2808 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2811 MXFContext *mxf = s->priv_data;
2814 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2815 PRINT_KEY(s, "read packet", klv.key);
2816 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2817 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2818 ret = mxf_decrypt_triplet(s, pkt, &klv);
2820 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2825 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2826 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2827 int index = mxf_get_stream_index(s, &klv);
2828 int64_t next_ofs, next_klv;
2831 AVCodecContext *codec;
2834 av_log(s, AV_LOG_ERROR,
2835 "error getting stream index %"PRIu32"\n",
2836 AV_RB32(klv.key + 12));
2840 st = s->streams[index];
2841 track = st->priv_data;
2843 if (s->streams[index]->discard == AVDISCARD_ALL)
2846 next_klv = avio_tell(s->pb) + klv.length;
2847 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2849 if (next_ofs >= 0 && next_klv > next_ofs) {
2850 /* if this check is hit then it's possible OPAtom was treated as OP1a
2851 * truncate the packet since it's probably very large (>2 GiB is common) */
2852 avpriv_request_sample(s,
2853 "OPAtom misinterpreted as OP1a?"
2854 "KLV for edit unit %i extending into "
2856 mxf->current_edit_unit);
2857 klv.length = next_ofs - avio_tell(s->pb);
2860 /* check for 8 channels AES3 element */
2861 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2862 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2865 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2869 ret = av_get_packet(s->pb, pkt, klv.length);
2873 pkt->stream_index = index;
2874 pkt->pos = klv.offset;
2878 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2879 /* mxf->current_edit_unit good - see if we have an
2880 * index table to derive timestamps from */
2881 MXFIndexTable *t = &mxf->index_tables[0];
2883 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2884 pkt->dts = mxf->current_edit_unit + t->first_dts;
2885 pkt->pts = t->ptses[mxf->current_edit_unit];
2886 } else if (track->intra_only) {
2887 /* intra-only -> PTS = EditUnit.
2888 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2889 pkt->pts = mxf->current_edit_unit;
2891 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2892 ret = mxf_set_audio_pts(mxf, codec, pkt);
2897 /* seek for truncated packets */
2898 avio_seek(s->pb, next_klv, SEEK_SET);
2903 avio_skip(s->pb, klv.length);
2905 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2908 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2910 MXFContext *mxf = s->priv_data;
2912 int64_t ret64, pos, next_pos;
2917 if (mxf->op != OPAtom)
2918 return mxf_read_packet_old(s, pkt);
2920 /* OPAtom - clip wrapped demuxing */
2921 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2923 t = &mxf->index_tables[0];
2925 if (mxf->current_edit_unit >= st->duration)
2928 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2930 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2933 /* compute size by finding the next edit unit or the end of the essence container
2934 * not pretty, but it works */
2935 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2936 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2937 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2938 return AVERROR_INVALIDDATA;
2941 if ((size = next_pos - pos) <= 0) {
2942 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2943 return AVERROR_INVALIDDATA;
2946 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2949 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2952 pkt->stream_index = 0;
2954 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2955 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2956 pkt->dts = mxf->current_edit_unit + t->first_dts;
2957 pkt->pts = t->ptses[mxf->current_edit_unit];
2958 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2959 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2964 mxf->current_edit_unit += edit_units;
2969 static int mxf_read_close(AVFormatContext *s)
2971 MXFContext *mxf = s->priv_data;
2974 av_freep(&mxf->packages_refs);
2976 for (i = 0; i < s->nb_streams; i++)
2977 s->streams[i]->priv_data = NULL;
2979 for (i = 0; i < mxf->metadata_sets_count; i++) {
2980 mxf_free_metadataset(mxf->metadata_sets + i);
2982 av_freep(&mxf->partitions);
2983 av_freep(&mxf->metadata_sets);
2984 av_freep(&mxf->aesc);
2985 av_freep(&mxf->local_tags);
2987 if (mxf->index_tables) {
2988 for (i = 0; i < mxf->nb_index_tables; i++) {
2989 av_freep(&mxf->index_tables[i].segments);
2990 av_freep(&mxf->index_tables[i].ptses);
2991 av_freep(&mxf->index_tables[i].fake_index);
2994 av_freep(&mxf->index_tables);
2999 static int mxf_probe(AVProbeData *p) {
3000 const uint8_t *bufp = p->buf;
3001 const uint8_t *end = p->buf + p->buf_size;
3003 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3006 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3007 end -= sizeof(mxf_header_partition_pack_key);
3009 for (; bufp < end;) {
3010 if (!((bufp[13] - 1) & 0xF2)){
3011 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3012 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3013 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3014 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3015 return AVPROBE_SCORE_MAX;
3024 /* rudimentary byte seek */
3025 /* XXX: use MXF Index */
3026 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3028 AVStream *st = s->streams[stream_index];
3030 MXFContext* mxf = s->priv_data;
3034 MXFTrack *source_track = st->priv_data;
3036 /* if audio then truncate sample_time to EditRate */
3037 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3038 sample_time = av_rescale_q(sample_time, st->time_base,
3039 av_inv_q(source_track->edit_rate));
3041 if (mxf->nb_index_tables <= 0) {
3043 return AVERROR_INVALIDDATA;
3044 if (sample_time < 0)
3046 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3048 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3052 ff_update_cur_dts(s, st, sample_time);
3053 mxf->current_edit_unit = sample_time;
3055 t = &mxf->index_tables[0];
3057 /* clamp above zero, else ff_index_search_timestamp() returns negative
3058 * this also means we allow seeking before the start */
3059 sample_time = FFMAX(sample_time, 0);
3061 if (t->fake_index) {
3062 /* behave as if we have a proper index */
3063 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3066 /* no IndexEntryArray (one or more CBR segments)
3067 * make sure we don't seek past the end */
3068 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3071 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3074 ff_update_cur_dts(s, st, sample_time);
3075 mxf->current_edit_unit = sample_time;
3076 avio_seek(s->pb, seekpos, SEEK_SET);
3079 // Update all tracks sample count
3080 for (i = 0; i < s->nb_streams; i++) {
3081 AVStream *cur_st = s->streams[i];
3082 MXFTrack *cur_track = cur_st->priv_data;
3083 uint64_t current_sample_count = 0;
3084 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3085 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3089 cur_track->sample_count = current_sample_count;
3095 AVInputFormat ff_mxf_demuxer = {
3097 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3098 .priv_data_size = sizeof(MXFContext),
3099 .read_probe = mxf_probe,
3100 .read_header = mxf_read_header,
3101 .read_packet = mxf_read_packet,
3102 .read_close = mxf_read_close,
3103 .read_seek = mxf_read_seek,