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 */
78 typedef struct MXFPartition {
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
95 typedef struct MXFCryptoContext {
97 enum MXFMetadataSetType type;
98 UID source_container_ul;
101 typedef struct MXFStructuralComponent {
103 enum MXFMetadataSetType type;
104 UID source_package_uid;
105 UID data_definition_ul;
107 int64_t start_position;
109 } MXFStructuralComponent;
111 typedef struct MXFSequence {
113 enum MXFMetadataSetType type;
114 UID data_definition_ul;
115 UID *structural_components_refs;
116 int structural_components_count;
121 typedef struct MXFTrack {
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 */
157 typedef struct MXFDescriptor {
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;
184 typedef struct MXFIndexTableSegment {
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;
199 typedef struct MXFPackage {
201 enum MXFMetadataSetType type;
206 MXFDescriptor *descriptor; /* only one */
211 typedef struct MXFMetadataSet {
213 enum MXFMetadataSetType type;
216 /* decoded index table */
217 typedef struct MXFIndexTable {
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() */
228 typedef struct MXFContext {
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);
262 typedef struct MXFMetadataReadTableEntry {
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, int freectx)
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);
320 static int64_t klv_decode_ber_length(AVIOContext *pb)
322 uint64_t size = avio_r8(pb);
323 if (size & 0x80) { /* long form */
324 int bytes_num = size & 0x7f;
325 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
327 return AVERROR_INVALIDDATA;
330 size = size << 8 | avio_r8(pb);
335 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
338 for (i = 0; i < size && !avio_feof(pb); i++) {
342 else if (b != key[i])
348 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
350 if (!mxf_read_sync(pb, mxf_klv_key, 4))
351 return AVERROR_INVALIDDATA;
352 klv->offset = avio_tell(pb) - 4;
353 memcpy(klv->key, mxf_klv_key, 4);
354 avio_read(pb, klv->key + 4, 12);
355 klv->length = klv_decode_ber_length(pb);
356 return klv->length == -1 ? -1 : 0;
359 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
363 for (i = 0; i < s->nb_streams; i++) {
364 MXFTrack *track = s->streams[i]->priv_data;
366 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
369 /* return 0 if only one stream, for OP Atom files with 0 as track number */
370 return s->nb_streams == 1 ? 0 : -1;
373 /* XXX: use AVBitStreamFilter */
374 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
376 const uint8_t *buf_ptr, *end_ptr;
380 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
381 return AVERROR_INVALIDDATA;
382 length = av_get_packet(pb, pkt, length);
385 data_ptr = pkt->data;
386 end_ptr = pkt->data + length;
387 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
388 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
389 for (i = 0; i < st->codec->channels; i++) {
390 uint32_t sample = bytestream_get_le32(&buf_ptr);
391 if (st->codec->bits_per_coded_sample == 24)
392 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
394 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
396 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
398 av_shrink_packet(pkt, data_ptr - pkt->data);
402 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
404 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
405 MXFContext *mxf = s->priv_data;
406 AVIOContext *pb = s->pb;
407 int64_t end = avio_tell(pb) + klv->length;
410 uint64_t plaintext_size;
415 if (!mxf->aesc && s->key && s->keylen == 16) {
416 mxf->aesc = av_aes_alloc();
418 return AVERROR(ENOMEM);
419 av_aes_init(mxf->aesc, s->key, 128, 1);
422 avio_skip(pb, klv_decode_ber_length(pb));
424 klv_decode_ber_length(pb);
425 plaintext_size = avio_rb64(pb);
427 klv_decode_ber_length(pb);
428 avio_read(pb, klv->key, 16);
429 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
430 return AVERROR_INVALIDDATA;
431 index = mxf_get_stream_index(s, klv);
433 return AVERROR_INVALIDDATA;
435 klv_decode_ber_length(pb);
436 orig_size = avio_rb64(pb);
437 if (orig_size < plaintext_size)
438 return AVERROR_INVALIDDATA;
440 size = klv_decode_ber_length(pb);
441 if (size < 32 || size - 32 < orig_size)
442 return AVERROR_INVALIDDATA;
443 avio_read(pb, ivec, 16);
444 avio_read(pb, tmpbuf, 16);
446 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
447 if (memcmp(tmpbuf, checkv, 16))
448 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
450 size = av_get_packet(pb, pkt, size);
453 else if (size < plaintext_size)
454 return AVERROR_INVALIDDATA;
455 size -= plaintext_size;
457 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
458 &pkt->data[plaintext_size], size >> 4, ivec, 1);
459 av_shrink_packet(pkt, orig_size);
460 pkt->stream_index = index;
461 avio_skip(pb, end - avio_tell(pb));
465 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
467 MXFContext *mxf = arg;
468 int item_num = avio_rb32(pb);
469 int item_len = avio_rb32(pb);
471 if (item_len != 18) {
472 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
473 return AVERROR_PATCHWELCOME;
475 if (item_num > 65536) {
476 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
477 return AVERROR_INVALIDDATA;
480 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
481 av_free(mxf->local_tags);
482 mxf->local_tags_count = 0;
483 mxf->local_tags = av_calloc(item_num, item_len);
484 if (!mxf->local_tags)
485 return AVERROR(ENOMEM);
486 mxf->local_tags_count = item_num;
487 avio_read(pb, mxf->local_tags, item_num*item_len);
491 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
493 MXFContext *mxf = arg;
494 MXFPartition *partition, *tmp_part;
496 uint64_t footer_partition;
497 uint32_t nb_essence_containers;
499 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
501 return AVERROR(ENOMEM);
502 mxf->partitions = tmp_part;
504 if (mxf->parsing_backward) {
505 /* insert the new partition pack in the middle
506 * this makes the entries in mxf->partitions sorted by offset */
507 memmove(&mxf->partitions[mxf->last_forward_partition+1],
508 &mxf->partitions[mxf->last_forward_partition],
509 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
510 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
512 mxf->last_forward_partition++;
513 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
516 memset(partition, 0, sizeof(*partition));
517 mxf->partitions_count++;
518 partition->pack_length = avio_tell(pb) - klv_offset + size;
519 partition->pack_ofs = klv_offset;
523 partition->type = Header;
526 partition->type = BodyPartition;
529 partition->type = Footer;
532 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
533 return AVERROR_INVALIDDATA;
536 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
537 partition->closed = partition->type == Footer || !(uid[14] & 1);
538 partition->complete = uid[14] > 2;
540 partition->kag_size = avio_rb32(pb);
541 partition->this_partition = avio_rb64(pb);
542 partition->previous_partition = avio_rb64(pb);
543 footer_partition = avio_rb64(pb);
544 partition->header_byte_count = avio_rb64(pb);
545 partition->index_byte_count = avio_rb64(pb);
546 partition->index_sid = avio_rb32(pb);
548 partition->body_sid = avio_rb32(pb);
549 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
550 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
551 return AVERROR_INVALIDDATA;
553 nb_essence_containers = avio_rb32(pb);
555 if (partition->this_partition &&
556 partition->previous_partition == partition->this_partition) {
557 av_log(mxf->fc, AV_LOG_ERROR,
558 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
559 partition->previous_partition);
560 /* override with the actual previous partition offset */
561 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
563 mxf->partitions + mxf->last_forward_partition - 2;
564 partition->previous_partition = prev->this_partition;
566 /* if no previous body partition are found point to the header
568 if (partition->previous_partition == partition->this_partition)
569 partition->previous_partition = 0;
570 av_log(mxf->fc, AV_LOG_ERROR,
571 "Overriding PreviousPartition with %"PRIx64"\n",
572 partition->previous_partition);
575 /* some files don'thave FooterPartition set in every partition */
576 if (footer_partition) {
577 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
578 av_log(mxf->fc, AV_LOG_ERROR,
579 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
580 mxf->footer_partition, footer_partition);
582 mxf->footer_partition = footer_partition;
587 "PartitionPack: ThisPartition = 0x%"PRIX64
588 ", PreviousPartition = 0x%"PRIX64", "
589 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
590 partition->this_partition,
591 partition->previous_partition, footer_partition,
592 partition->index_sid, partition->body_sid);
594 /* sanity check PreviousPartition if set */
595 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
596 if (partition->previous_partition &&
597 mxf->run_in + partition->previous_partition >= klv_offset) {
598 av_log(mxf->fc, AV_LOG_ERROR,
599 "PreviousPartition points to this partition or forward\n");
600 return AVERROR_INVALIDDATA;
603 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
604 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
605 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
606 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
607 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
608 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
609 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
610 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
611 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
612 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
613 else if (op[12] == 0x10) {
614 /* SMPTE 390m: "There shall be exactly one essence container"
615 * The following block deals with files that violate this, namely:
616 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
617 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
618 if (nb_essence_containers != 1) {
619 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
623 av_log(mxf->fc, AV_LOG_WARNING,
624 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
625 nb_essence_containers,
626 op == OP1a ? "OP1a" : "OPAtom");
632 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
636 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
637 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
638 partition->kag_size);
640 if (mxf->op == OPSONYOpt)
641 partition->kag_size = 512;
643 partition->kag_size = 1;
645 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
651 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
653 MXFMetadataSet **tmp;
655 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
657 return AVERROR(ENOMEM);
658 mxf->metadata_sets = tmp;
659 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
660 mxf->metadata_sets_count++;
664 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
666 MXFCryptoContext *cryptocontext = arg;
668 return AVERROR_INVALIDDATA;
669 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
670 avio_read(pb, cryptocontext->source_container_ul, 16);
674 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
676 MXFContext *mxf = arg;
679 if (mxf->packages_refs)
680 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
681 av_free(mxf->packages_refs);
682 mxf->packages_count = avio_rb32(pb);
683 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
684 if (!mxf->packages_refs)
685 return AVERROR(ENOMEM);
686 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
687 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
693 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
695 MXFStructuralComponent *source_clip = arg;
698 source_clip->duration = avio_rb64(pb);
701 source_clip->start_position = avio_rb64(pb);
704 /* UMID, only get last 16 bytes */
706 avio_read(pb, source_clip->source_package_uid, 16);
709 source_clip->source_track_id = avio_rb32(pb);
715 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
717 MXFTimecodeComponent *mxf_timecode = arg;
720 mxf_timecode->start_frame = avio_rb64(pb);
723 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
726 mxf_timecode->drop_frame = avio_r8(pb);
732 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
734 MXFPulldownComponent *mxf_pulldown = arg;
737 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
743 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
745 MXFTrack *track = arg;
748 track->track_id = avio_rb32(pb);
751 avio_read(pb, track->track_number, 4);
754 track->edit_rate.num = avio_rb32(pb);
755 track->edit_rate.den = avio_rb32(pb);
758 avio_read(pb, track->sequence_ref, 16);
764 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
766 MXFSequence *sequence = arg;
769 sequence->duration = avio_rb64(pb);
772 avio_read(pb, sequence->data_definition_ul, 16);
775 sequence->origin = avio_r8(pb);
778 sequence->structural_components_count = avio_rb32(pb);
779 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
780 if (!sequence->structural_components_refs) {
781 sequence->structural_components_count = 0;
782 return AVERROR(ENOMEM);
784 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
785 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
791 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
793 MXFEssenceGroup *essence_group = arg;
796 essence_group->duration = avio_rb64(pb);
799 essence_group->structural_components_count = avio_rb32(pb);
800 essence_group->structural_components_refs = av_calloc(essence_group->structural_components_count, sizeof(UID));
801 if (!essence_group->structural_components_refs) {
802 essence_group->structural_components_count = 0;
803 return AVERROR(ENOMEM);
805 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
806 avio_read(pb, (uint8_t *)essence_group->structural_components_refs, essence_group->structural_components_count * sizeof(UID));
812 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
818 return AVERROR(EINVAL);
820 buf_size = size + size / 2 + 1;
821 *str = av_malloc(buf_size);
823 return AVERROR(ENOMEM);
825 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
833 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
835 MXFPackage *package = arg;
838 package->tracks_count = avio_rb32(pb);
839 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
840 if (!package->tracks_refs)
841 return AVERROR(ENOMEM);
842 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
843 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
847 avio_read(pb, package->package_ul, 16);
848 avio_read(pb, package->package_uid, 16);
851 avio_read(pb, package->descriptor_ref, 16);
854 return mxf_read_utf16_string(pb, size, &package->name);
859 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
863 segment->nb_index_entries = avio_rb32(pb);
865 length = avio_rb32(pb);
867 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
868 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
869 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
870 av_freep(&segment->temporal_offset_entries);
871 av_freep(&segment->flag_entries);
872 return AVERROR(ENOMEM);
875 for (i = 0; i < segment->nb_index_entries; i++) {
876 segment->temporal_offset_entries[i] = avio_r8(pb);
877 avio_r8(pb); /* KeyFrameOffset */
878 segment->flag_entries[i] = avio_r8(pb);
879 segment->stream_offset_entries[i] = avio_rb64(pb);
880 avio_skip(pb, length - 11);
885 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
887 MXFIndexTableSegment *segment = arg;
890 segment->edit_unit_byte_count = avio_rb32(pb);
891 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
894 segment->index_sid = avio_rb32(pb);
895 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
898 segment->body_sid = avio_rb32(pb);
899 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
902 av_dlog(NULL, "IndexEntryArray found\n");
903 return mxf_read_index_entry_array(pb, segment);
905 segment->index_edit_rate.num = avio_rb32(pb);
906 segment->index_edit_rate.den = avio_rb32(pb);
907 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
908 segment->index_edit_rate.den);
911 segment->index_start_position = avio_rb64(pb);
912 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
915 segment->index_duration = avio_rb64(pb);
916 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
922 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
924 int code, value, ofs = 0;
925 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
930 av_dlog(NULL, "pixel layout: code %#x\n", code);
933 layout[ofs++] = code;
934 layout[ofs++] = value;
936 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
937 } while (code != 0); /* SMPTE 377M E.2.46 */
939 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
942 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
944 MXFDescriptor *descriptor = arg;
947 descriptor->sub_descriptors_count = avio_rb32(pb);
948 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
949 if (!descriptor->sub_descriptors_refs)
950 return AVERROR(ENOMEM);
951 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
952 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
954 case 0x3002: /* ContainerDuration */
955 descriptor->duration = avio_rb64(pb);
958 avio_read(pb, descriptor->essence_container_ul, 16);
961 descriptor->linked_track_id = avio_rb32(pb);
963 case 0x3201: /* PictureEssenceCoding */
964 avio_read(pb, descriptor->essence_codec_ul, 16);
967 descriptor->width = avio_rb32(pb);
970 descriptor->height = avio_rb32(pb);
973 descriptor->frame_layout = avio_r8(pb);
976 descriptor->aspect_ratio.num = avio_rb32(pb);
977 descriptor->aspect_ratio.den = avio_rb32(pb);
980 descriptor->field_dominance = avio_r8(pb);
983 descriptor->component_depth = avio_rb32(pb);
986 descriptor->horiz_subsampling = avio_rb32(pb);
989 descriptor->vert_subsampling = avio_rb32(pb);
992 descriptor->sample_rate.num = avio_rb32(pb);
993 descriptor->sample_rate.den = avio_rb32(pb);
995 case 0x3D06: /* SoundEssenceCompression */
996 avio_read(pb, descriptor->essence_codec_ul, 16);
999 descriptor->channels = avio_rb32(pb);
1002 descriptor->bits_per_sample = avio_rb32(pb);
1005 mxf_read_pixel_layout(pb, descriptor);
1008 /* Private uid used by SONY C0023S01.mxf */
1009 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1010 if (descriptor->extradata)
1011 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1012 av_free(descriptor->extradata);
1013 descriptor->extradata_size = 0;
1014 descriptor->extradata = av_malloc(size);
1015 if (!descriptor->extradata)
1016 return AVERROR(ENOMEM);
1017 descriptor->extradata_size = size;
1018 avio_read(pb, descriptor->extradata, size);
1026 * Match an uid independently of the version byte and up to len common bytes
1029 static int mxf_match_uid(const UID key, const UID uid, int len)
1032 for (i = 0; i < len; i++) {
1033 if (i != 7 && key[i] != uid[i])
1039 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1041 while (uls->uid[0]) {
1042 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1049 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1055 for (i = 0; i < mxf->metadata_sets_count; i++) {
1056 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1057 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1058 return mxf->metadata_sets[i];
1064 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1065 // video essence container uls
1066 { { 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 */
1067 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1068 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
1069 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1070 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1073 /* EC ULs for intra-only formats */
1074 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1075 { { 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 */
1076 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1079 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1080 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1081 { { 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 */
1082 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
1083 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1086 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1087 // sound essence container uls
1088 { { 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 */
1089 { { 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 */
1090 { { 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 */
1091 { { 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 */
1092 { { 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) */
1093 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1096 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1097 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1098 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1101 static const char* const mxf_data_essence_descriptor[] = {
1102 "vbi_vanc_smpte_436M",
1105 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1107 int i, j, nb_segments = 0;
1108 MXFIndexTableSegment **unsorted_segments;
1109 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1111 /* count number of segments, allocate arrays and copy unsorted segments */
1112 for (i = 0; i < mxf->metadata_sets_count; i++)
1113 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1117 return AVERROR_INVALIDDATA;
1119 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1120 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1121 av_freep(sorted_segments);
1122 av_free(unsorted_segments);
1123 return AVERROR(ENOMEM);
1126 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1127 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1128 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1130 *nb_sorted_segments = 0;
1132 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1133 for (i = 0; i < nb_segments; i++) {
1134 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1135 uint64_t best_index_duration = 0;
1137 for (j = 0; j < nb_segments; j++) {
1138 MXFIndexTableSegment *s = unsorted_segments[j];
1140 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1141 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1142 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1144 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1145 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1146 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1148 best_body_sid = s->body_sid;
1149 best_index_sid = s->index_sid;
1150 best_index_start = s->index_start_position;
1151 best_index_duration = s->index_duration;
1155 /* no suitable entry found -> we're done */
1159 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1160 last_body_sid = best_body_sid;
1161 last_index_sid = best_index_sid;
1162 last_index_start = best_index_start;
1165 av_free(unsorted_segments);
1171 * Computes the absolute file offset of the given essence container offset
1173 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1176 int64_t offset_in = offset; /* for logging */
1178 for (x = 0; x < mxf->partitions_count; x++) {
1179 MXFPartition *p = &mxf->partitions[x];
1181 if (p->body_sid != body_sid)
1184 if (offset < p->essence_length || !p->essence_length) {
1185 *offset_out = p->essence_offset + offset;
1189 offset -= p->essence_length;
1192 av_log(mxf->fc, AV_LOG_ERROR,
1193 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1194 offset_in, body_sid);
1196 return AVERROR_INVALIDDATA;
1200 * Returns the end position of the essence container with given BodySID, or zero if unknown
1202 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1207 for (x = 0; x < mxf->partitions_count; x++) {
1208 MXFPartition *p = &mxf->partitions[x];
1210 if (p->body_sid != body_sid)
1213 if (!p->essence_length)
1216 ret = p->essence_offset + p->essence_length;
1222 /* EditUnit -> absolute offset */
1223 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)
1226 int64_t offset_temp = 0;
1228 for (i = 0; i < index_table->nb_segments; i++) {
1229 MXFIndexTableSegment *s = index_table->segments[i];
1231 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1233 if (edit_unit < s->index_start_position + s->index_duration) {
1234 int64_t index = edit_unit - s->index_start_position;
1236 if (s->edit_unit_byte_count)
1237 offset_temp += s->edit_unit_byte_count * index;
1238 else if (s->nb_index_entries) {
1239 if (s->nb_index_entries == 2 * s->index_duration + 1)
1240 index *= 2; /* Avid index */
1242 if (index < 0 || index >= s->nb_index_entries) {
1243 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1244 index_table->index_sid, s->index_start_position);
1245 return AVERROR_INVALIDDATA;
1248 offset_temp = s->stream_offset_entries[index];
1250 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1251 index_table->index_sid, s->index_start_position);
1252 return AVERROR_INVALIDDATA;
1256 *edit_unit_out = edit_unit;
1258 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1260 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1261 offset_temp += s->edit_unit_byte_count * s->index_duration;
1266 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);
1268 return AVERROR_INVALIDDATA;
1271 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1274 int8_t max_temporal_offset = -128;
1276 /* first compute how many entries we have */
1277 for (i = 0; i < index_table->nb_segments; i++) {
1278 MXFIndexTableSegment *s = index_table->segments[i];
1280 if (!s->nb_index_entries) {
1281 index_table->nb_ptses = 0;
1282 return 0; /* no TemporalOffsets */
1285 index_table->nb_ptses += s->index_duration;
1288 /* paranoid check */
1289 if (index_table->nb_ptses <= 0)
1292 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1293 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1294 av_freep(&index_table->ptses);
1295 return AVERROR(ENOMEM);
1298 /* we may have a few bad TemporalOffsets
1299 * make sure the corresponding PTSes don't have the bogus value 0 */
1300 for (x = 0; x < index_table->nb_ptses; x++)
1301 index_table->ptses[x] = AV_NOPTS_VALUE;
1315 * We want to transform it into this:
1326 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1327 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1328 * The latter makes DTS <= PTS.
1330 for (i = x = 0; i < index_table->nb_segments; i++) {
1331 MXFIndexTableSegment *s = index_table->segments[i];
1332 int index_delta = 1;
1333 int n = s->nb_index_entries;
1335 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1336 index_delta = 2; /* Avid index */
1337 /* ignore the last entry - it's the size of the essence container */
1341 for (j = 0; j < n; j += index_delta, x++) {
1342 int offset = s->temporal_offset_entries[j] / index_delta;
1343 int index = x + offset;
1345 if (x >= index_table->nb_ptses) {
1346 av_log(mxf->fc, AV_LOG_ERROR,
1347 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1348 s->nb_index_entries, s->index_duration);
1352 index_table->fake_index[x].timestamp = x;
1353 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1355 if (index < 0 || index >= index_table->nb_ptses) {
1356 av_log(mxf->fc, AV_LOG_ERROR,
1357 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1362 index_table->ptses[index] = x;
1363 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1367 index_table->first_dts = -max_temporal_offset;
1373 * Sorts and collects index table segments into index tables.
1374 * Also computes PTSes if possible.
1376 static int mxf_compute_index_tables(MXFContext *mxf)
1378 int i, j, k, ret, nb_sorted_segments;
1379 MXFIndexTableSegment **sorted_segments = NULL;
1381 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1382 nb_sorted_segments <= 0) {
1383 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1387 /* sanity check and count unique BodySIDs/IndexSIDs */
1388 for (i = 0; i < nb_sorted_segments; i++) {
1389 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1390 mxf->nb_index_tables++;
1391 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1392 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1393 ret = AVERROR_INVALIDDATA;
1394 goto finish_decoding_index;
1398 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1399 sizeof(*mxf->index_tables));
1400 if (!mxf->index_tables) {
1401 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1402 ret = AVERROR(ENOMEM);
1403 goto finish_decoding_index;
1406 /* distribute sorted segments to index tables */
1407 for (i = j = 0; i < nb_sorted_segments; i++) {
1408 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1413 mxf->index_tables[j].nb_segments++;
1416 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1417 MXFIndexTable *t = &mxf->index_tables[j];
1419 t->segments = av_mallocz_array(t->nb_segments,
1420 sizeof(*t->segments));
1423 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1424 " pointer array\n");
1425 ret = AVERROR(ENOMEM);
1426 goto finish_decoding_index;
1429 if (sorted_segments[i]->index_start_position)
1430 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1431 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1433 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1434 t->index_sid = sorted_segments[i]->index_sid;
1435 t->body_sid = sorted_segments[i]->body_sid;
1437 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1438 goto finish_decoding_index;
1440 /* fix zero IndexDurations */
1441 for (k = 0; k < t->nb_segments; k++) {
1442 if (t->segments[k]->index_duration)
1445 if (t->nb_segments > 1)
1446 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1449 if (mxf->fc->nb_streams <= 0) {
1450 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1454 /* assume the first stream's duration is reasonable
1455 * leave index_duration = 0 on further segments in case we have any (unlikely)
1457 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1463 finish_decoding_index:
1464 av_free(sorted_segments);
1468 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1470 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1471 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1472 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1473 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1476 static int mxf_uid_to_str(UID uid, char **str)
1480 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1482 return AVERROR(ENOMEM);
1483 for (i = 0; i < sizeof(UID); i++) {
1484 snprintf(p, 2 + 1, "%.2x", uid[i]);
1486 if (i == 3 || i == 5 || i == 7 || i == 9) {
1487 snprintf(p, 1 + 1, "-");
1494 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1498 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1500 return AVERROR(ENOMEM);
1501 snprintf(p, 2 + 1, "0x");
1503 for (i = 0; i < sizeof(UID); i++) {
1504 snprintf(p, 2 + 1, "%.2X", ul[i]);
1508 for (i = 0; i < sizeof(UID); i++) {
1509 snprintf(p, 2 + 1, "%.2X", uid[i]);
1515 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1521 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1523 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1527 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1529 char buf[AV_TIMECODE_STR_SIZE];
1530 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1535 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1537 MXFStructuralComponent *component = NULL;
1538 MXFPulldownComponent *pulldown = NULL;
1540 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1544 switch (component->type) {
1545 case TimecodeComponent:
1546 return (MXFTimecodeComponent*)component;
1547 case PulldownComponent: /* timcode component may be located on a pulldown component */
1548 pulldown = (MXFPulldownComponent*)component;
1549 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1556 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1558 MXFPackage *package = NULL;
1561 for (i = 0; i < mxf->packages_count; i++) {
1562 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1566 if (!memcmp(package->package_uid, package_uid, 16))
1572 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1574 MXFDescriptor *sub_descriptor = NULL;
1580 if (descriptor->type == MultipleDescriptor) {
1581 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1582 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1584 if (!sub_descriptor) {
1585 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1588 if (sub_descriptor->linked_track_id == track_id) {
1589 return sub_descriptor;
1592 } else if (descriptor->type == Descriptor)
1598 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1600 MXFStructuralComponent *component = NULL;
1601 MXFPackage *package = NULL;
1602 MXFDescriptor *descriptor = NULL;
1605 if (!essence_group || !essence_group->structural_components_count)
1608 /* essence groups contains multiple representations of the same media,
1609 this return the first components with a valid Descriptor typically index 0 */
1610 for (i =0; i < essence_group->structural_components_count; i++){
1611 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1615 if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1618 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1625 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1627 MXFStructuralComponent *component = NULL;
1629 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1632 switch (component->type) {
1636 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1643 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1645 MXFPackage *physical_package = NULL;
1646 MXFTrack *physical_track = NULL;
1647 MXFStructuralComponent *sourceclip = NULL;
1648 MXFTimecodeComponent *mxf_tc = NULL;
1652 int64_t start_position;
1654 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1655 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1659 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1662 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1664 /* the name of physical source package is name of the reel or tape */
1665 if (physical_package->name && physical_package->name[0])
1666 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1668 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1669 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1671 for (j = 0; j < physical_package->tracks_count; j++) {
1672 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1673 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1677 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1678 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1682 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1683 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1686 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1687 /* scale sourceclip start_position to match physical track edit rate */
1688 start_position = av_rescale_q(sourceclip->start_position,
1689 physical_track->edit_rate,
1690 source_track->edit_rate);
1692 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1693 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1703 static int mxf_parse_structural_metadata(MXFContext *mxf)
1705 MXFPackage *material_package = NULL;
1708 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1709 /* TODO: handle multiple material packages (OP3x) */
1710 for (i = 0; i < mxf->packages_count; i++) {
1711 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1712 if (material_package) break;
1714 if (!material_package) {
1715 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1716 return AVERROR_INVALIDDATA;
1719 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1720 if (material_package->name && material_package->name[0])
1721 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1723 for (i = 0; i < material_package->tracks_count; i++) {
1724 MXFPackage *source_package = NULL;
1725 MXFTrack *material_track = NULL;
1726 MXFTrack *source_track = NULL;
1727 MXFTrack *temp_track = NULL;
1728 MXFDescriptor *descriptor = NULL;
1729 MXFStructuralComponent *component = NULL;
1730 MXFTimecodeComponent *mxf_tc = NULL;
1731 UID *essence_container_ul = NULL;
1732 const MXFCodecUL *codec_ul = NULL;
1733 const MXFCodecUL *container_ul = NULL;
1734 const MXFCodecUL *pix_fmt_ul = NULL;
1739 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1740 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1744 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1745 mxf_tc = (MXFTimecodeComponent*)component;
1746 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1747 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1748 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1752 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1753 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1757 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1758 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1762 mxf_tc = (MXFTimecodeComponent*)component;
1763 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1764 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1765 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1770 /* TODO: handle multiple source clips */
1771 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1772 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1776 source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1777 if (!source_package) {
1778 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1781 for (k = 0; k < source_package->tracks_count; k++) {
1782 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1783 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1784 ret = AVERROR_INVALIDDATA;
1787 if (temp_track->track_id == component->source_track_id) {
1788 source_track = temp_track;
1792 if (!source_track) {
1793 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1797 if (!source_track || !component)
1800 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1801 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1802 ret = AVERROR_INVALIDDATA;
1806 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1807 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1808 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1809 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1813 st = avformat_new_stream(mxf->fc, NULL);
1815 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1816 ret = AVERROR(ENOMEM);
1819 st->id = source_track->track_id;
1820 st->priv_data = source_track;
1822 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1823 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1825 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1826 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1827 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1828 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1830 source_track->original_duration = st->duration = component->duration;
1832 if (st->duration == -1)
1833 st->duration = AV_NOPTS_VALUE;
1834 st->start_time = component->start_position;
1835 if (material_track->edit_rate.num <= 0 ||
1836 material_track->edit_rate.den <= 0) {
1837 av_log(mxf->fc, AV_LOG_WARNING,
1838 "Invalid edit rate (%d/%d) found on stream #%d, "
1839 "defaulting to 25/1\n",
1840 material_track->edit_rate.num,
1841 material_track->edit_rate.den, st->index);
1842 material_track->edit_rate = (AVRational){25, 1};
1844 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1846 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1847 * the former is accessible via st->priv_data */
1848 source_track->edit_rate = material_track->edit_rate;
1850 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1851 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1852 st->codec->codec_type = codec_ul->id;
1855 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1858 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1859 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1860 essence_container_ul = &descriptor->essence_container_ul;
1861 /* HACK: replacing the original key with mxf_encrypted_essence_container
1862 * is not allowed according to s429-6, try to find correct information anyway */
1863 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1864 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1865 for (k = 0; k < mxf->metadata_sets_count; k++) {
1866 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1867 if (metadata->type == CryptoContext) {
1868 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1874 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1875 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1876 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1877 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1878 avcodec_get_name(st->codec->codec_id));
1879 for (k = 0; k < 16; k++) {
1880 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1881 descriptor->essence_codec_ul[k]);
1882 if (!(k+1 & 19) || k == 5)
1883 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1885 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1887 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
1888 if (source_package->name && source_package->name[0])
1889 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
1891 mxf_parse_physical_source_package(mxf, source_track, st);
1893 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1894 source_track->intra_only = mxf_is_intra_only(descriptor);
1895 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1896 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1897 st->codec->codec_id = container_ul->id;
1898 st->codec->width = descriptor->width;
1899 st->codec->height = descriptor->height; /* Field height, not frame height */
1900 switch (descriptor->frame_layout) {
1901 case SegmentedFrame:
1902 /* This one is a weird layout I don't fully understand. */
1903 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1906 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1909 /* Every other line is stored and needs to be duplicated. */
1910 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1911 break; /* The correct thing to do here is fall through, but by breaking we might be
1912 able to decode some streams at half the vertical resolution, rather than not al all.
1913 It's also for compatibility with the old behavior. */
1916 case SeparateFields:
1917 switch (descriptor->field_dominance) {
1919 st->codec->field_order = AV_FIELD_TT;
1922 st->codec->field_order = AV_FIELD_BB;
1925 avpriv_request_sample(mxf->fc,
1926 "Field dominance %d support",
1927 descriptor->field_dominance);
1928 case 0: // we already have many samples with field_dominance == unknown
1931 /* Turn field height into frame height. */
1932 st->codec->height *= 2;
1935 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1937 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1938 st->codec->pix_fmt = descriptor->pix_fmt;
1939 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1940 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1941 &descriptor->essence_codec_ul);
1942 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1943 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1944 /* support files created before RP224v10 by defaulting to UYVY422
1945 if subsampling is 4:2:2 and component depth is 8-bit */
1946 if (descriptor->horiz_subsampling == 2 &&
1947 descriptor->vert_subsampling == 1 &&
1948 descriptor->component_depth == 8) {
1949 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1954 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1955 if (material_track->sequence->origin) {
1956 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1958 if (source_track->sequence->origin) {
1959 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1961 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1962 st->display_aspect_ratio = descriptor->aspect_ratio;
1963 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1964 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1965 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1966 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))
1967 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1968 st->codec->channels = descriptor->channels;
1969 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1971 if (descriptor->sample_rate.den > 0) {
1972 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1973 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1975 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1976 "found for stream #%d, time base forced to 1/48000\n",
1977 descriptor->sample_rate.num, descriptor->sample_rate.den,
1979 avpriv_set_pts_info(st, 64, 1, 48000);
1982 /* if duration is set, rescale it from EditRate to SampleRate */
1983 if (st->duration != AV_NOPTS_VALUE)
1984 st->duration = av_rescale_q(st->duration,
1985 av_inv_q(material_track->edit_rate),
1988 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1989 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1990 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1991 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1992 else if (descriptor->bits_per_sample == 32)
1993 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1994 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1995 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1996 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1997 else if (descriptor->bits_per_sample == 32)
1998 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1999 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
2000 st->need_parsing = AVSTREAM_PARSE_FULL;
2002 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2003 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2004 essence_container_ul)->id;
2005 if (codec_id >= 0 &&
2006 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2007 av_dict_set(&st->metadata, "data_type",
2008 mxf_data_essence_descriptor[codec_id], 0);
2011 if (descriptor->extradata) {
2012 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
2013 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
2015 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
2016 ret = ff_generate_avci_extradata(st);
2020 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2021 /* TODO: decode timestamps */
2022 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2031 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2033 struct tm time = { 0 };
2034 time.tm_year = (timestamp >> 48) - 1900;
2035 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2036 time.tm_mday = (timestamp >> 32 & 0xFF);
2037 time.tm_hour = (timestamp >> 24 & 0xFF);
2038 time.tm_min = (timestamp >> 16 & 0xFF);
2039 time.tm_sec = (timestamp >> 8 & 0xFF);
2041 /* msvcrt versions of strftime calls the invalid parameter handler
2042 * (aborting the process if one isn't set) if the parameters are out
2044 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2045 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2046 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2047 time.tm_min = av_clip(time.tm_min, 0, 59);
2048 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2050 *str = av_mallocz(32);
2052 return AVERROR(ENOMEM);
2053 if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2059 #define SET_STR_METADATA(pb, name, str) do { \
2060 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
2062 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2065 #define SET_UID_METADATA(pb, name, var, str) do { \
2066 avio_read(pb, var, 16); \
2067 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2069 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2072 #define SET_TS_METADATA(pb, name, var, str) do { \
2073 var = avio_rb64(pb); \
2074 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2076 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2079 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2081 MXFContext *mxf = arg;
2082 AVFormatContext *s = mxf->fc;
2089 SET_STR_METADATA(pb, "company_name", str);
2092 SET_STR_METADATA(pb, "product_name", str);
2095 SET_STR_METADATA(pb, "product_version", str);
2098 SET_UID_METADATA(pb, "product_uid", uid, str);
2101 SET_TS_METADATA(pb, "modification_date", ts, str);
2104 SET_STR_METADATA(pb, "application_platform", str);
2107 SET_UID_METADATA(pb, "generation_uid", uid, str);
2110 SET_UID_METADATA(pb, "uid", uid, str);
2116 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2118 MXFContext *mxf = arg;
2119 AVFormatContext *s = mxf->fc;
2123 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2124 SET_STR_METADATA(pb, "project_name", str);
2129 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2130 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2131 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2132 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2133 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2134 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2135 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2136 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2137 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2138 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2139 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2140 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2141 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2142 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2143 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2144 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2145 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2146 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2147 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2148 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2149 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2150 { { 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 */
2151 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2152 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2153 { { 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 */
2154 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2155 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2156 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2157 { { 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 */
2158 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2159 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2160 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2161 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2162 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2163 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2164 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2165 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2168 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2171 case MultipleDescriptor:
2173 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2174 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2182 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2184 AVIOContext *pb = mxf->fc->pb;
2185 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2186 uint64_t klv_end = avio_tell(pb) + klv->length;
2189 return AVERROR(ENOMEM);
2190 mxf_metadataset_init(ctx, type);
2191 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2193 int tag = avio_rb16(pb);
2194 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2195 uint64_t next = avio_tell(pb) + size;
2198 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2199 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2200 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2203 if (tag > 0x7FFF) { /* dynamic tag */
2205 for (i = 0; i < mxf->local_tags_count; i++) {
2206 int local_tag = AV_RB16(mxf->local_tags+i*18);
2207 if (local_tag == tag) {
2208 memcpy(uid, mxf->local_tags+i*18+2, 16);
2209 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2210 PRINT_KEY(mxf->fc, "uid", uid);
2214 if (ctx_size && tag == 0x3C0A) {
2215 avio_read(pb, ctx->uid, 16);
2216 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2217 mxf_free_metadataset(&ctx, !!ctx_size);
2221 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2222 * it extending past the end of the KLV though (zzuf5.mxf). */
2223 if (avio_tell(pb) > klv_end) {
2226 mxf_free_metadataset(&ctx, !!ctx_size);
2229 av_log(mxf->fc, AV_LOG_ERROR,
2230 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2232 return AVERROR_INVALIDDATA;
2233 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2234 avio_seek(pb, next, SEEK_SET);
2236 if (ctx_size) ctx->type = type;
2237 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2241 * Matches any partition pack key, in other words:
2245 * @return non-zero if the key is a partition pack key, zero otherwise
2247 static int mxf_is_partition_pack_key(UID key)
2249 //NOTE: this is a little lax since it doesn't constraint key[14]
2250 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2251 key[13] >= 2 && key[13] <= 4;
2255 * Parses a metadata KLV
2256 * @return <0 on error, 0 otherwise
2258 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2259 int ctx_size, enum MXFMetadataSetType type)
2261 AVFormatContext *s = mxf->fc;
2263 if (klv.key[5] == 0x53) {
2264 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2266 uint64_t next = avio_tell(s->pb) + klv.length;
2267 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2269 /* only seek forward, else this can loop for a long time */
2270 if (avio_tell(s->pb) > next) {
2271 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2273 return AVERROR_INVALIDDATA;
2276 avio_seek(s->pb, next, SEEK_SET);
2279 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2286 * Seeks to the previous partition and parses it, if possible
2287 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2289 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2291 AVIOContext *pb = mxf->fc->pb;
2293 int64_t current_partition_ofs;
2296 if (!mxf->current_partition ||
2297 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2298 return 0; /* we've parsed all partitions */
2300 /* seek to previous partition */
2301 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2302 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2303 mxf->current_partition = NULL;
2305 av_dlog(mxf->fc, "seeking to previous partition\n");
2307 /* Make sure this is actually a PartitionPack, and if so parse it.
2310 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2311 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2315 if (!mxf_is_partition_pack_key(klv.key)) {
2316 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2317 return AVERROR_INVALIDDATA;
2320 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2321 * can point to just before the current partition, causing klv_read_packet()
2322 * to sync back up to it. See deadlock3.mxf
2324 if (klv.offset >= current_partition_ofs) {
2325 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2326 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2327 return AVERROR_INVALIDDATA;
2330 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2337 * Called when essence is encountered
2338 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2340 static int mxf_parse_handle_essence(MXFContext *mxf)
2342 AVIOContext *pb = mxf->fc->pb;
2345 if (mxf->parsing_backward) {
2346 return mxf_seek_to_previous_partition(mxf);
2348 if (!mxf->footer_partition) {
2349 av_dlog(mxf->fc, "no FooterPartition\n");
2353 av_dlog(mxf->fc, "seeking to FooterPartition\n");
2355 /* remember where we were so we don't end up seeking further back than this */
2356 mxf->last_forward_tell = avio_tell(pb);
2358 if (!pb->seekable) {
2359 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2363 /* seek to FooterPartition and parse backward */
2364 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2365 av_log(mxf->fc, AV_LOG_ERROR,
2366 "failed to seek to FooterPartition @ 0x%" PRIx64
2367 " (%"PRId64") - partial file?\n",
2368 mxf->run_in + mxf->footer_partition, ret);
2372 mxf->current_partition = NULL;
2373 mxf->parsing_backward = 1;
2380 * Called when the next partition or EOF is encountered
2381 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2383 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2385 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2389 * Figures out the proper offset and length of the essence container in each partition
2391 static void mxf_compute_essence_containers(MXFContext *mxf)
2395 /* everything is already correct */
2396 if (mxf->op == OPAtom)
2399 for (x = 0; x < mxf->partitions_count; x++) {
2400 MXFPartition *p = &mxf->partitions[x];
2403 continue; /* BodySID == 0 -> no essence */
2405 if (x >= mxf->partitions_count - 1)
2406 break; /* FooterPartition - can't compute length (and we don't need to) */
2408 /* essence container spans to the next partition */
2409 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2411 if (p->essence_length < 0) {
2412 /* next ThisPartition < essence_offset */
2413 p->essence_length = 0;
2414 av_log(mxf->fc, AV_LOG_ERROR,
2415 "partition %i: bad ThisPartition = %"PRIX64"\n",
2416 x+1, mxf->partitions[x+1].this_partition);
2421 static int64_t round_to_kag(int64_t position, int kag_size)
2423 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2424 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2425 int64_t ret = (position / kag_size) * kag_size;
2426 return ret == position ? ret : ret + kag_size;
2429 static int is_pcm(enum AVCodecID codec_id)
2431 /* we only care about "normal" PCM codecs until we get samples */
2432 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2436 * Deal with the case where for some audio atoms EditUnitByteCount is
2437 * very small (2, 4..). In those cases we should read more than one
2438 * sample per call to mxf_read_packet().
2440 static void mxf_handle_small_eubc(AVFormatContext *s)
2442 MXFContext *mxf = s->priv_data;
2444 /* assuming non-OPAtom == frame wrapped
2445 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2446 if (mxf->op != OPAtom)
2449 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2450 if (s->nb_streams != 1 ||
2451 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2452 !is_pcm(s->streams[0]->codec->codec_id) ||
2453 mxf->nb_index_tables != 1 ||
2454 mxf->index_tables[0].nb_segments != 1 ||
2455 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2458 /* arbitrarily default to 48 kHz PAL audio frame size */
2459 /* TODO: We could compute this from the ratio between the audio
2460 * and video edit rates for 48 kHz NTSC we could use the
2461 * 1802-1802-1802-1802-1801 pattern. */
2462 mxf->edit_units_per_packet = 1920;
2466 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2468 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2470 AVFormatContext *s = mxf->fc;
2471 AVStream *st = NULL;
2472 MXFIndexTableSegment *segment = NULL;
2473 MXFPartition *p = NULL;
2474 int essence_partition_count = 0;
2477 if (mxf->op != OPAtom)
2480 /* TODO: support raw video without a index if they exist */
2481 if (s->nb_streams != 1 || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(s->streams[0]->codec->codec_id))
2484 /* check if file already has a IndexTableSegment */
2485 for (i = 0; i < mxf->metadata_sets_count; i++) {
2486 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2490 /* find the essence partition */
2491 for (i = 0; i < mxf->partitions_count; i++) {
2492 /* BodySID == 0 -> no essence */
2493 if (!mxf->partitions[i].body_sid)
2496 p = &mxf->partitions[i];
2497 essence_partition_count++;
2500 /* only handle files with a single essence partition */
2501 if (essence_partition_count != 1)
2504 if (!(segment = av_mallocz(sizeof(*segment))))
2505 return AVERROR(ENOMEM);
2507 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2508 mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2513 segment->type = IndexTableSegment;
2514 /* stream will be treated as small EditUnitByteCount */
2515 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
2516 segment->index_start_position = 0;
2517 segment->index_duration = s->streams[0]->duration;
2518 segment->index_sid = p->index_sid;
2519 segment->body_sid = p->body_sid;
2523 static void mxf_read_random_index_pack(AVFormatContext *s)
2525 MXFContext *mxf = s->priv_data;
2527 int64_t file_size, max_rip_length, min_rip_length;
2530 if (!s->pb->seekable)
2533 file_size = avio_size(s->pb);
2535 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2536 * The limit below assumes a file with nothing but partition packs and a RIP.
2537 * Before changing this, consider that a muxer may place each sample in its own partition.
2539 * 105 is the size of the smallest possible PartitionPack
2540 * 12 is the size of each RIP entry
2541 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2543 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2544 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2546 /* We're only interested in RIPs with at least two entries.. */
2547 min_rip_length = 16+1+24+4;
2549 /* See S377m section 11 */
2550 avio_seek(s->pb, file_size - 4, SEEK_SET);
2551 length = avio_rb32(s->pb);
2553 if (length < min_rip_length || length > max_rip_length)
2555 avio_seek(s->pb, file_size - length, SEEK_SET);
2556 if (klv_read_packet(&klv, s->pb) < 0 ||
2557 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2558 klv.length != length - 20)
2561 avio_skip(s->pb, klv.length - 12);
2562 mxf->footer_partition = avio_rb64(s->pb);
2565 if (mxf->run_in + mxf->footer_partition >= file_size) {
2566 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2567 mxf->footer_partition = 0;
2571 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2574 static int mxf_read_header(AVFormatContext *s)
2576 MXFContext *mxf = s->priv_data;
2578 int64_t essence_offset = 0;
2581 mxf->last_forward_tell = INT64_MAX;
2582 mxf->edit_units_per_packet = 1;
2584 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2585 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2586 return AVERROR_INVALIDDATA;
2588 avio_seek(s->pb, -14, SEEK_CUR);
2590 mxf->run_in = avio_tell(s->pb);
2592 mxf_read_random_index_pack(s);
2594 while (!avio_feof(s->pb)) {
2595 const MXFMetadataReadTableEntry *metadata;
2597 if (klv_read_packet(&klv, s->pb) < 0) {
2598 /* EOF - seek to previous partition or stop */
2599 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2605 PRINT_KEY(s, "read header", klv.key);
2606 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2607 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2608 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2609 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2610 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2612 if (!mxf->current_partition) {
2613 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2614 return AVERROR_INVALIDDATA;
2617 if (!mxf->current_partition->essence_offset) {
2618 /* for OP1a we compute essence_offset
2619 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2620 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2621 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2623 int64_t op1a_essence_offset =
2624 round_to_kag(mxf->current_partition->this_partition +
2625 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2626 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2627 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2629 if (mxf->op == OPAtom) {
2630 /* point essence_offset to the actual data
2631 * OPAtom has all the essence in one big KLV
2633 mxf->current_partition->essence_offset = avio_tell(s->pb);
2634 mxf->current_partition->essence_length = klv.length;
2636 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2637 mxf->current_partition->essence_offset = op1a_essence_offset;
2641 if (!essence_offset)
2642 essence_offset = klv.offset;
2644 /* seek to footer, previous partition or stop */
2645 if (mxf_parse_handle_essence(mxf) <= 0)
2648 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2649 /* next partition pack - keep going, seek to previous partition or stop */
2650 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2652 else if (mxf->parsing_backward)
2654 /* we're still parsing forward. proceed to parsing this partition pack */
2657 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2658 if (IS_KLV_KEY(klv.key, metadata->key)) {
2659 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2663 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2667 if (!metadata->read)
2668 avio_skip(s->pb, klv.length);
2670 /* FIXME avoid seek */
2671 if (!essence_offset) {
2672 av_log(s, AV_LOG_ERROR, "no essence\n");
2673 ret = AVERROR_INVALIDDATA;
2676 avio_seek(s->pb, essence_offset, SEEK_SET);
2678 mxf_compute_essence_containers(mxf);
2680 /* we need to do this before computing the index tables
2681 * to be able to fill in zero IndexDurations with st->duration */
2682 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2685 mxf_handle_missing_index_segment(mxf);
2686 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2689 if (mxf->nb_index_tables > 1) {
2690 /* TODO: look up which IndexSID to use via EssenceContainerData */
2691 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2692 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2693 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2694 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2695 ret = AVERROR_INVALIDDATA;
2699 mxf_handle_small_eubc(s);
2709 * Sets mxf->current_edit_unit based on what offset we're currently at.
2710 * @return next_ofs if OK, <0 on error
2712 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2714 int64_t last_ofs = -1, next_ofs = -1;
2715 MXFIndexTable *t = &mxf->index_tables[0];
2717 /* this is called from the OP1a demuxing logic, which means there
2718 * may be no index tables */
2719 if (mxf->nb_index_tables <= 0)
2722 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2723 while (mxf->current_edit_unit >= 0) {
2724 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2727 if (next_ofs <= last_ofs) {
2728 /* large next_ofs didn't change or current_edit_unit wrapped
2729 * around this fixes the infinite loop on zzuf3.mxf */
2730 av_log(mxf->fc, AV_LOG_ERROR,
2731 "next_ofs didn't change. not deriving packet timestamps\n");
2735 if (next_ofs > current_offset)
2738 last_ofs = next_ofs;
2739 mxf->current_edit_unit++;
2742 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2743 if (mxf->current_edit_unit < 0)
2749 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2750 uint64_t *sample_count)
2752 int i, total = 0, size = 0;
2753 AVStream *st = mxf->fc->streams[stream_index];
2754 MXFTrack *track = st->priv_data;
2755 AVRational time_base = av_inv_q(track->edit_rate);
2756 AVRational sample_rate = av_inv_q(st->time_base);
2757 const MXFSamplesPerFrame *spf = NULL;
2759 if ((sample_rate.num / sample_rate.den) == 48000)
2760 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2762 int remainder = (sample_rate.num * time_base.num) %
2763 (time_base.den * sample_rate.den);
2764 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2765 av_mul_q(sample_rate, time_base)));
2767 av_log(mxf->fc, AV_LOG_WARNING,
2768 "seeking detected on stream #%d with time base (%d/%d) and "
2769 "sample rate (%d/%d), audio pts won't be accurate.\n",
2770 stream_index, time_base.num, time_base.den,
2771 sample_rate.num, sample_rate.den);
2775 while (spf->samples_per_frame[size]) {
2776 total += spf->samples_per_frame[size];
2782 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2783 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2784 *sample_count += spf->samples_per_frame[i];
2790 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2793 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2794 int64_t bits_per_sample = codec->bits_per_coded_sample;
2796 if (!bits_per_sample)
2797 bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2799 pkt->pts = track->sample_count;
2801 if ( codec->channels <= 0
2802 || bits_per_sample <= 0
2803 || codec->channels * (int64_t)bits_per_sample < 8)
2804 return AVERROR(EINVAL);
2805 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2809 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2812 MXFContext *mxf = s->priv_data;
2815 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2816 PRINT_KEY(s, "read packet", klv.key);
2817 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2818 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2819 ret = mxf_decrypt_triplet(s, pkt, &klv);
2821 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2826 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2827 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2828 int index = mxf_get_stream_index(s, &klv);
2829 int64_t next_ofs, next_klv;
2832 AVCodecContext *codec;
2835 av_log(s, AV_LOG_ERROR,
2836 "error getting stream index %"PRIu32"\n",
2837 AV_RB32(klv.key + 12));
2841 st = s->streams[index];
2842 track = st->priv_data;
2844 if (s->streams[index]->discard == AVDISCARD_ALL)
2847 next_klv = avio_tell(s->pb) + klv.length;
2848 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2850 if (next_ofs >= 0 && next_klv > next_ofs) {
2851 /* if this check is hit then it's possible OPAtom was treated as OP1a
2852 * truncate the packet since it's probably very large (>2 GiB is common) */
2853 avpriv_request_sample(s,
2854 "OPAtom misinterpreted as OP1a?"
2855 "KLV for edit unit %i extending into "
2857 mxf->current_edit_unit);
2858 klv.length = next_ofs - avio_tell(s->pb);
2861 /* check for 8 channels AES3 element */
2862 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2863 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2866 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2870 ret = av_get_packet(s->pb, pkt, klv.length);
2874 pkt->stream_index = index;
2875 pkt->pos = klv.offset;
2879 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2880 /* mxf->current_edit_unit good - see if we have an
2881 * index table to derive timestamps from */
2882 MXFIndexTable *t = &mxf->index_tables[0];
2884 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2885 pkt->dts = mxf->current_edit_unit + t->first_dts;
2886 pkt->pts = t->ptses[mxf->current_edit_unit];
2887 } else if (track->intra_only) {
2888 /* intra-only -> PTS = EditUnit.
2889 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2890 pkt->pts = mxf->current_edit_unit;
2892 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2893 ret = mxf_set_audio_pts(mxf, codec, pkt);
2898 /* seek for truncated packets */
2899 avio_seek(s->pb, next_klv, SEEK_SET);
2904 avio_skip(s->pb, klv.length);
2906 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2909 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2911 MXFContext *mxf = s->priv_data;
2913 int64_t ret64, pos, next_pos;
2918 if (mxf->op != OPAtom)
2919 return mxf_read_packet_old(s, pkt);
2921 /* OPAtom - clip wrapped demuxing */
2922 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2924 t = &mxf->index_tables[0];
2926 if (mxf->current_edit_unit >= st->duration)
2929 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2931 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2934 /* compute size by finding the next edit unit or the end of the essence container
2935 * not pretty, but it works */
2936 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2937 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2938 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2939 return AVERROR_INVALIDDATA;
2942 if ((size = next_pos - pos) <= 0) {
2943 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2944 return AVERROR_INVALIDDATA;
2947 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2950 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2953 pkt->stream_index = 0;
2955 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2956 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2957 pkt->dts = mxf->current_edit_unit + t->first_dts;
2958 pkt->pts = t->ptses[mxf->current_edit_unit];
2959 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2960 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2965 mxf->current_edit_unit += edit_units;
2970 static int mxf_read_close(AVFormatContext *s)
2972 MXFContext *mxf = s->priv_data;
2975 av_freep(&mxf->packages_refs);
2977 for (i = 0; i < s->nb_streams; i++)
2978 s->streams[i]->priv_data = NULL;
2980 for (i = 0; i < mxf->metadata_sets_count; i++) {
2981 mxf_free_metadataset(mxf->metadata_sets + i, 1);
2983 av_freep(&mxf->partitions);
2984 av_freep(&mxf->metadata_sets);
2985 av_freep(&mxf->aesc);
2986 av_freep(&mxf->local_tags);
2988 if (mxf->index_tables) {
2989 for (i = 0; i < mxf->nb_index_tables; i++) {
2990 av_freep(&mxf->index_tables[i].segments);
2991 av_freep(&mxf->index_tables[i].ptses);
2992 av_freep(&mxf->index_tables[i].fake_index);
2995 av_freep(&mxf->index_tables);
3000 static int mxf_probe(AVProbeData *p) {
3001 const uint8_t *bufp = p->buf;
3002 const uint8_t *end = p->buf + p->buf_size;
3004 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3007 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3008 end -= sizeof(mxf_header_partition_pack_key);
3010 for (; bufp < end;) {
3011 if (!((bufp[13] - 1) & 0xF2)){
3012 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3013 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3014 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3015 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3016 return AVPROBE_SCORE_MAX;
3025 /* rudimentary byte seek */
3026 /* XXX: use MXF Index */
3027 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3029 AVStream *st = s->streams[stream_index];
3031 MXFContext* mxf = s->priv_data;
3035 MXFTrack *source_track = st->priv_data;
3037 /* if audio then truncate sample_time to EditRate */
3038 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3039 sample_time = av_rescale_q(sample_time, st->time_base,
3040 av_inv_q(source_track->edit_rate));
3042 if (mxf->nb_index_tables <= 0) {
3044 return AVERROR_INVALIDDATA;
3045 if (sample_time < 0)
3047 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3049 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3053 ff_update_cur_dts(s, st, sample_time);
3054 mxf->current_edit_unit = sample_time;
3056 t = &mxf->index_tables[0];
3058 /* clamp above zero, else ff_index_search_timestamp() returns negative
3059 * this also means we allow seeking before the start */
3060 sample_time = FFMAX(sample_time, 0);
3062 if (t->fake_index) {
3063 /* behave as if we have a proper index */
3064 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3067 /* no IndexEntryArray (one or more CBR segments)
3068 * make sure we don't seek past the end */
3069 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3072 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3075 ff_update_cur_dts(s, st, sample_time);
3076 mxf->current_edit_unit = sample_time;
3077 avio_seek(s->pb, seekpos, SEEK_SET);
3080 // Update all tracks sample count
3081 for (i = 0; i < s->nb_streams; i++) {
3082 AVStream *cur_st = s->streams[i];
3083 MXFTrack *cur_track = cur_st->priv_data;
3084 uint64_t current_sample_count = 0;
3085 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3086 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3090 cur_track->sample_count = current_sample_count;
3096 AVInputFormat ff_mxf_demuxer = {
3098 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3099 .priv_data_size = sizeof(MXFContext),
3100 .read_probe = mxf_probe,
3101 .read_header = mxf_read_header,
3102 .read_packet = mxf_read_packet,
3103 .read_close = mxf_read_close,
3104 .read_seek = mxf_read_seek,