3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
33 * Search for Track numbers which will identify essence element KLV packets.
34 * Search for SourcePackage which define tracks which contains Track numbers.
35 * Material Package contains tracks with reference to SourcePackage tracks.
36 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37 * Assign Descriptors to correct Tracks.
39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40 * Metadata parsing resolves Strong References to objects.
42 * Simple demuxer, only OP1A supported and some files might not work at all.
43 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/timecode.h"
75 OPSONYOpt, /* FATE sample, violates the spec in places */
81 MXFPartitionType type;
82 uint64_t previous_partition;
85 int64_t this_partition;
86 int64_t essence_offset; ///< absolute offset of essence
87 int64_t essence_length;
89 int64_t header_byte_count;
90 int64_t index_byte_count;
92 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
97 enum MXFMetadataSetType type;
98 UID source_container_ul;
103 enum MXFMetadataSetType type;
104 UID source_package_uid;
105 UID data_definition_ul;
107 int64_t start_position;
109 } MXFStructuralComponent;
113 enum MXFMetadataSetType type;
114 UID data_definition_ul;
115 UID *structural_components_refs;
116 int structural_components_count;
123 enum MXFMetadataSetType type;
126 struct AVRational rate;
128 } MXFTimecodeComponent;
132 enum MXFMetadataSetType type;
133 UID input_segment_ref;
134 } MXFPulldownComponent;
138 enum MXFMetadataSetType type;
139 UID *structural_components_refs;
140 int structural_components_count;
146 enum MXFMetadataSetType type;
147 MXFSequence *sequence; /* mandatory, and only one */
150 uint8_t track_number[4];
151 AVRational edit_rate;
153 uint64_t sample_count;
154 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
159 enum MXFMetadataSetType type;
160 UID essence_container_ul;
161 UID essence_codec_ul;
162 AVRational sample_rate;
163 AVRational aspect_ratio;
165 int height; /* Field height, not frame height */
166 int frame_layout; /* See MXFFrameLayout enum */
172 int64_t duration; /* ContainerDuration optional property */
173 unsigned int component_depth;
174 unsigned int horiz_subsampling;
175 unsigned int vert_subsampling;
176 UID *sub_descriptors_refs;
177 int sub_descriptors_count;
181 enum AVPixelFormat pix_fmt;
186 enum MXFMetadataSetType type;
187 int edit_unit_byte_count;
190 AVRational index_edit_rate;
191 uint64_t index_start_position;
192 uint64_t index_duration;
193 int8_t *temporal_offset_entries;
195 uint64_t *stream_offset_entries;
196 int nb_index_entries;
197 } MXFIndexTableSegment;
201 enum MXFMetadataSetType type;
205 MXFDescriptor *descriptor; /* only one */
212 enum MXFMetadataSetType type;
215 /* decoded index table */
219 int nb_ptses; /* number of PTSes or total duration of index */
220 int64_t first_dts; /* DTS = EditUnit + first_dts */
221 int64_t *ptses; /* maps EditUnit -> PTS */
223 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
224 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
228 MXFPartition *partitions;
229 unsigned partitions_count;
233 MXFMetadataSet **metadata_sets;
234 int metadata_sets_count;
238 int local_tags_count;
239 uint64_t footer_partition;
240 KLVPacket current_klv_data;
241 int current_klv_index;
243 MXFPartition *current_partition;
244 int parsing_backward;
245 int64_t last_forward_tell;
246 int last_forward_partition;
247 int current_edit_unit;
249 MXFIndexTable *index_tables;
250 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
253 enum MXFWrappingScheme {
258 /* NOTE: klv_offset is not set (-1) for local keys */
259 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
263 MXFMetadataReadFunc *read;
265 enum MXFMetadataSetType type;
266 } MXFMetadataReadTableEntry;
268 static int mxf_read_close(AVFormatContext *s);
270 /* partial keys to match */
271 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
272 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
273 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
274 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
275 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
276 /* complete keys to match */
277 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 };
278 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
279 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
280 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 };
281 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 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
285 static void mxf_free_metadataset(MXFMetadataSet **ctx)
287 MXFIndexTableSegment *seg;
288 switch ((*ctx)->type) {
290 av_freep(&((MXFDescriptor *)*ctx)->extradata);
292 case MultipleDescriptor:
293 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
296 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
299 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
302 case MaterialPackage:
303 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
304 av_freep(&((MXFPackage *)*ctx)->name);
306 case IndexTableSegment:
307 seg = (MXFIndexTableSegment *)*ctx;
308 av_freep(&seg->temporal_offset_entries);
309 av_freep(&seg->flag_entries);
310 av_freep(&seg->stream_offset_entries);
317 static int64_t klv_decode_ber_length(AVIOContext *pb)
319 uint64_t size = avio_r8(pb);
320 if (size & 0x80) { /* long form */
321 int bytes_num = size & 0x7f;
322 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
324 return AVERROR_INVALIDDATA;
327 size = size << 8 | avio_r8(pb);
332 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
335 for (i = 0; i < size && !avio_feof(pb); i++) {
339 else if (b != key[i])
345 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
347 if (!mxf_read_sync(pb, mxf_klv_key, 4))
348 return AVERROR_INVALIDDATA;
349 klv->offset = avio_tell(pb) - 4;
350 memcpy(klv->key, mxf_klv_key, 4);
351 avio_read(pb, klv->key + 4, 12);
352 klv->length = klv_decode_ber_length(pb);
353 return klv->length == -1 ? -1 : 0;
356 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
360 for (i = 0; i < s->nb_streams; i++) {
361 MXFTrack *track = s->streams[i]->priv_data;
363 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
366 /* return 0 if only one stream, for OP Atom files with 0 as track number */
367 return s->nb_streams == 1 ? 0 : -1;
370 /* XXX: use AVBitStreamFilter */
371 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
373 const uint8_t *buf_ptr, *end_ptr;
377 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
378 return AVERROR_INVALIDDATA;
379 length = av_get_packet(pb, pkt, length);
382 data_ptr = pkt->data;
383 end_ptr = pkt->data + length;
384 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
385 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
386 for (i = 0; i < st->codec->channels; i++) {
387 uint32_t sample = bytestream_get_le32(&buf_ptr);
388 if (st->codec->bits_per_coded_sample == 24)
389 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
391 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
393 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
395 av_shrink_packet(pkt, data_ptr - pkt->data);
399 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
401 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
402 MXFContext *mxf = s->priv_data;
403 AVIOContext *pb = s->pb;
404 int64_t end = avio_tell(pb) + klv->length;
407 uint64_t plaintext_size;
412 if (!mxf->aesc && s->key && s->keylen == 16) {
413 mxf->aesc = av_aes_alloc();
415 return AVERROR(ENOMEM);
416 av_aes_init(mxf->aesc, s->key, 128, 1);
419 avio_skip(pb, klv_decode_ber_length(pb));
421 klv_decode_ber_length(pb);
422 plaintext_size = avio_rb64(pb);
424 klv_decode_ber_length(pb);
425 avio_read(pb, klv->key, 16);
426 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
427 return AVERROR_INVALIDDATA;
428 index = mxf_get_stream_index(s, klv);
430 return AVERROR_INVALIDDATA;
432 klv_decode_ber_length(pb);
433 orig_size = avio_rb64(pb);
434 if (orig_size < plaintext_size)
435 return AVERROR_INVALIDDATA;
437 size = klv_decode_ber_length(pb);
438 if (size < 32 || size - 32 < orig_size)
439 return AVERROR_INVALIDDATA;
440 avio_read(pb, ivec, 16);
441 avio_read(pb, tmpbuf, 16);
443 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
444 if (memcmp(tmpbuf, checkv, 16))
445 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
447 size = av_get_packet(pb, pkt, size);
450 else if (size < plaintext_size)
451 return AVERROR_INVALIDDATA;
452 size -= plaintext_size;
454 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
455 &pkt->data[plaintext_size], size >> 4, ivec, 1);
456 av_shrink_packet(pkt, orig_size);
457 pkt->stream_index = index;
458 avio_skip(pb, end - avio_tell(pb));
462 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
464 MXFContext *mxf = arg;
465 int item_num = avio_rb32(pb);
466 int item_len = avio_rb32(pb);
468 if (item_len != 18) {
469 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
470 return AVERROR_PATCHWELCOME;
472 if (item_num > 65536) {
473 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
474 return AVERROR_INVALIDDATA;
477 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
478 av_free(mxf->local_tags);
479 mxf->local_tags_count = 0;
480 mxf->local_tags = av_calloc(item_num, item_len);
481 if (!mxf->local_tags)
482 return AVERROR(ENOMEM);
483 mxf->local_tags_count = item_num;
484 avio_read(pb, mxf->local_tags, item_num*item_len);
488 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
490 MXFContext *mxf = arg;
491 MXFPartition *partition, *tmp_part;
493 uint64_t footer_partition;
494 uint32_t nb_essence_containers;
496 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
498 return AVERROR(ENOMEM);
499 mxf->partitions = tmp_part;
501 if (mxf->parsing_backward) {
502 /* insert the new partition pack in the middle
503 * this makes the entries in mxf->partitions sorted by offset */
504 memmove(&mxf->partitions[mxf->last_forward_partition+1],
505 &mxf->partitions[mxf->last_forward_partition],
506 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
507 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
509 mxf->last_forward_partition++;
510 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
513 memset(partition, 0, sizeof(*partition));
514 mxf->partitions_count++;
515 partition->pack_length = avio_tell(pb) - klv_offset + size;
516 partition->pack_ofs = klv_offset;
520 partition->type = Header;
523 partition->type = BodyPartition;
526 partition->type = Footer;
529 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
530 return AVERROR_INVALIDDATA;
533 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
534 partition->closed = partition->type == Footer || !(uid[14] & 1);
535 partition->complete = uid[14] > 2;
537 partition->kag_size = avio_rb32(pb);
538 partition->this_partition = avio_rb64(pb);
539 partition->previous_partition = avio_rb64(pb);
540 footer_partition = avio_rb64(pb);
541 partition->header_byte_count = avio_rb64(pb);
542 partition->index_byte_count = avio_rb64(pb);
543 partition->index_sid = avio_rb32(pb);
545 partition->body_sid = avio_rb32(pb);
546 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
547 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
548 return AVERROR_INVALIDDATA;
550 nb_essence_containers = avio_rb32(pb);
552 if (partition->this_partition &&
553 partition->previous_partition == partition->this_partition) {
554 av_log(mxf->fc, AV_LOG_ERROR,
555 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
556 partition->previous_partition);
557 /* override with the actual previous partition offset */
558 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
560 mxf->partitions + mxf->last_forward_partition - 2;
561 partition->previous_partition = prev->this_partition;
563 /* if no previous body partition are found point to the header
565 if (partition->previous_partition == partition->this_partition)
566 partition->previous_partition = 0;
567 av_log(mxf->fc, AV_LOG_ERROR,
568 "Overriding PreviousPartition with %"PRIx64"\n",
569 partition->previous_partition);
572 /* some files don'thave FooterPartition set in every partition */
573 if (footer_partition) {
574 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
575 av_log(mxf->fc, AV_LOG_ERROR,
576 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
577 mxf->footer_partition, footer_partition);
579 mxf->footer_partition = footer_partition;
584 "PartitionPack: ThisPartition = 0x%"PRIX64
585 ", PreviousPartition = 0x%"PRIX64", "
586 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
587 partition->this_partition,
588 partition->previous_partition, footer_partition,
589 partition->index_sid, partition->body_sid);
591 /* sanity check PreviousPartition if set */
592 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
593 if (partition->previous_partition &&
594 mxf->run_in + partition->previous_partition >= klv_offset) {
595 av_log(mxf->fc, AV_LOG_ERROR,
596 "PreviousPartition points to this partition or forward\n");
597 return AVERROR_INVALIDDATA;
600 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
601 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
602 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
603 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
604 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
605 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
606 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
607 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
608 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
609 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
610 else if (op[12] == 0x10) {
611 /* SMPTE 390m: "There shall be exactly one essence container"
612 * The following block deals with files that violate this, namely:
613 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
614 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
615 if (nb_essence_containers != 1) {
616 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
620 av_log(mxf->fc, AV_LOG_WARNING,
621 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
622 nb_essence_containers,
623 op == OP1a ? "OP1a" : "OPAtom");
629 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
633 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
634 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
635 partition->kag_size);
637 if (mxf->op == OPSONYOpt)
638 partition->kag_size = 512;
640 partition->kag_size = 1;
642 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
648 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
650 MXFMetadataSet **tmp;
652 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
654 return AVERROR(ENOMEM);
655 mxf->metadata_sets = tmp;
656 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
657 mxf->metadata_sets_count++;
661 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
663 MXFCryptoContext *cryptocontext = arg;
665 return AVERROR_INVALIDDATA;
666 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
667 avio_read(pb, cryptocontext->source_container_ul, 16);
671 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
673 MXFContext *mxf = arg;
676 if (mxf->packages_refs)
677 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
678 av_free(mxf->packages_refs);
679 mxf->packages_count = avio_rb32(pb);
680 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
681 if (!mxf->packages_refs)
682 return AVERROR(ENOMEM);
683 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
684 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
690 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
692 MXFStructuralComponent *source_clip = arg;
695 source_clip->duration = avio_rb64(pb);
698 source_clip->start_position = avio_rb64(pb);
701 /* UMID, only get last 16 bytes */
703 avio_read(pb, source_clip->source_package_uid, 16);
706 source_clip->source_track_id = avio_rb32(pb);
712 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
714 MXFTimecodeComponent *mxf_timecode = arg;
717 mxf_timecode->start_frame = avio_rb64(pb);
720 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
723 mxf_timecode->drop_frame = avio_r8(pb);
729 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
731 MXFPulldownComponent *mxf_pulldown = arg;
734 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
740 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
742 MXFTrack *track = arg;
745 track->track_id = avio_rb32(pb);
748 avio_read(pb, track->track_number, 4);
751 track->edit_rate.num = avio_rb32(pb);
752 track->edit_rate.den = avio_rb32(pb);
755 avio_read(pb, track->sequence_ref, 16);
761 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
763 MXFSequence *sequence = arg;
766 sequence->duration = avio_rb64(pb);
769 avio_read(pb, sequence->data_definition_ul, 16);
772 sequence->origin = avio_r8(pb);
775 sequence->structural_components_count = avio_rb32(pb);
776 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
777 if (!sequence->structural_components_refs) {
778 sequence->structural_components_count = 0;
779 return AVERROR(ENOMEM);
781 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
782 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
788 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
790 MXFEssenceGroup *essence_group = arg;
793 essence_group->duration = avio_rb64(pb);
796 essence_group->structural_components_count = avio_rb32(pb);
797 essence_group->structural_components_refs = av_calloc(essence_group->structural_components_count, sizeof(UID));
798 if (!essence_group->structural_components_refs) {
799 essence_group->structural_components_count = 0;
800 return AVERROR(ENOMEM);
802 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
803 avio_read(pb, (uint8_t *)essence_group->structural_components_refs, essence_group->structural_components_count * sizeof(UID));
809 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
815 return AVERROR(EINVAL);
817 buf_size = size + size / 2 + 1;
818 *str = av_malloc(buf_size);
820 return AVERROR(ENOMEM);
822 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
830 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
832 MXFPackage *package = arg;
835 package->tracks_count = avio_rb32(pb);
836 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
837 if (!package->tracks_refs)
838 return AVERROR(ENOMEM);
839 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
840 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
843 /* UMID, only get last 16 bytes */
845 avio_read(pb, package->package_uid, 16);
848 avio_read(pb, package->descriptor_ref, 16);
851 return mxf_read_utf16_string(pb, size, &package->name);
856 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
860 segment->nb_index_entries = avio_rb32(pb);
862 length = avio_rb32(pb);
864 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
865 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
866 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
867 av_freep(&segment->temporal_offset_entries);
868 av_freep(&segment->flag_entries);
869 return AVERROR(ENOMEM);
872 for (i = 0; i < segment->nb_index_entries; i++) {
873 segment->temporal_offset_entries[i] = avio_r8(pb);
874 avio_r8(pb); /* KeyFrameOffset */
875 segment->flag_entries[i] = avio_r8(pb);
876 segment->stream_offset_entries[i] = avio_rb64(pb);
877 avio_skip(pb, length - 11);
882 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
884 MXFIndexTableSegment *segment = arg;
887 segment->edit_unit_byte_count = avio_rb32(pb);
888 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
891 segment->index_sid = avio_rb32(pb);
892 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
895 segment->body_sid = avio_rb32(pb);
896 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
899 av_dlog(NULL, "IndexEntryArray found\n");
900 return mxf_read_index_entry_array(pb, segment);
902 segment->index_edit_rate.num = avio_rb32(pb);
903 segment->index_edit_rate.den = avio_rb32(pb);
904 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
905 segment->index_edit_rate.den);
908 segment->index_start_position = avio_rb64(pb);
909 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
912 segment->index_duration = avio_rb64(pb);
913 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
919 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
921 int code, value, ofs = 0;
922 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
927 av_dlog(NULL, "pixel layout: code %#x\n", code);
930 layout[ofs++] = code;
931 layout[ofs++] = value;
933 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
934 } while (code != 0); /* SMPTE 377M E.2.46 */
936 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
939 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
941 MXFDescriptor *descriptor = arg;
944 descriptor->sub_descriptors_count = avio_rb32(pb);
945 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
946 if (!descriptor->sub_descriptors_refs)
947 return AVERROR(ENOMEM);
948 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
949 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
951 case 0x3002: /* ContainerDuration */
952 descriptor->duration = avio_rb64(pb);
955 avio_read(pb, descriptor->essence_container_ul, 16);
958 descriptor->linked_track_id = avio_rb32(pb);
960 case 0x3201: /* PictureEssenceCoding */
961 avio_read(pb, descriptor->essence_codec_ul, 16);
964 descriptor->width = avio_rb32(pb);
967 descriptor->height = avio_rb32(pb);
970 descriptor->frame_layout = avio_r8(pb);
973 descriptor->aspect_ratio.num = avio_rb32(pb);
974 descriptor->aspect_ratio.den = avio_rb32(pb);
977 descriptor->field_dominance = avio_r8(pb);
980 descriptor->component_depth = avio_rb32(pb);
983 descriptor->horiz_subsampling = avio_rb32(pb);
986 descriptor->vert_subsampling = avio_rb32(pb);
989 descriptor->sample_rate.num = avio_rb32(pb);
990 descriptor->sample_rate.den = avio_rb32(pb);
992 case 0x3D06: /* SoundEssenceCompression */
993 avio_read(pb, descriptor->essence_codec_ul, 16);
996 descriptor->channels = avio_rb32(pb);
999 descriptor->bits_per_sample = avio_rb32(pb);
1002 mxf_read_pixel_layout(pb, descriptor);
1005 /* Private uid used by SONY C0023S01.mxf */
1006 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1007 if (descriptor->extradata)
1008 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1009 av_free(descriptor->extradata);
1010 descriptor->extradata_size = 0;
1011 descriptor->extradata = av_malloc(size);
1012 if (!descriptor->extradata)
1013 return AVERROR(ENOMEM);
1014 descriptor->extradata_size = size;
1015 avio_read(pb, descriptor->extradata, size);
1023 * Match an uid independently of the version byte and up to len common bytes
1026 static int mxf_match_uid(const UID key, const UID uid, int len)
1029 for (i = 0; i < len; i++) {
1030 if (i != 7 && key[i] != uid[i])
1036 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1038 while (uls->uid[0]) {
1039 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1046 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1052 for (i = 0; i < mxf->metadata_sets_count; i++) {
1053 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1054 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1055 return mxf->metadata_sets[i];
1061 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1062 // video essence container uls
1063 { { 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 */
1064 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1065 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
1066 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1067 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1070 /* EC ULs for intra-only formats */
1071 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1072 { { 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 */
1073 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1076 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1077 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1078 { { 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 */
1079 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
1080 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1083 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1084 // sound essence container uls
1085 { { 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 */
1086 { { 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 */
1087 { { 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 */
1088 { { 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 */
1089 { { 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) */
1090 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1093 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1094 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1095 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1098 static const char* const mxf_data_essence_descriptor[] = {
1099 "vbi_vanc_smpte_436M",
1102 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1104 int i, j, nb_segments = 0;
1105 MXFIndexTableSegment **unsorted_segments;
1106 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1108 /* count number of segments, allocate arrays and copy unsorted segments */
1109 for (i = 0; i < mxf->metadata_sets_count; i++)
1110 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1114 return AVERROR_INVALIDDATA;
1116 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1117 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1118 av_freep(sorted_segments);
1119 av_free(unsorted_segments);
1120 return AVERROR(ENOMEM);
1123 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1124 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1125 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1127 *nb_sorted_segments = 0;
1129 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1130 for (i = 0; i < nb_segments; i++) {
1131 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1132 uint64_t best_index_duration = 0;
1134 for (j = 0; j < nb_segments; j++) {
1135 MXFIndexTableSegment *s = unsorted_segments[j];
1137 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1138 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1139 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1141 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1142 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1143 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1145 best_body_sid = s->body_sid;
1146 best_index_sid = s->index_sid;
1147 best_index_start = s->index_start_position;
1148 best_index_duration = s->index_duration;
1152 /* no suitable entry found -> we're done */
1156 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1157 last_body_sid = best_body_sid;
1158 last_index_sid = best_index_sid;
1159 last_index_start = best_index_start;
1162 av_free(unsorted_segments);
1168 * Computes the absolute file offset of the given essence container offset
1170 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1173 int64_t offset_in = offset; /* for logging */
1175 for (x = 0; x < mxf->partitions_count; x++) {
1176 MXFPartition *p = &mxf->partitions[x];
1178 if (p->body_sid != body_sid)
1181 if (offset < p->essence_length || !p->essence_length) {
1182 *offset_out = p->essence_offset + offset;
1186 offset -= p->essence_length;
1189 av_log(mxf->fc, AV_LOG_ERROR,
1190 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1191 offset_in, body_sid);
1193 return AVERROR_INVALIDDATA;
1197 * Returns the end position of the essence container with given BodySID, or zero if unknown
1199 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1204 for (x = 0; x < mxf->partitions_count; x++) {
1205 MXFPartition *p = &mxf->partitions[x];
1207 if (p->body_sid != body_sid)
1210 if (!p->essence_length)
1213 ret = p->essence_offset + p->essence_length;
1219 /* EditUnit -> absolute offset */
1220 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)
1223 int64_t offset_temp = 0;
1225 for (i = 0; i < index_table->nb_segments; i++) {
1226 MXFIndexTableSegment *s = index_table->segments[i];
1228 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1230 if (edit_unit < s->index_start_position + s->index_duration) {
1231 int64_t index = edit_unit - s->index_start_position;
1233 if (s->edit_unit_byte_count)
1234 offset_temp += s->edit_unit_byte_count * index;
1235 else if (s->nb_index_entries) {
1236 if (s->nb_index_entries == 2 * s->index_duration + 1)
1237 index *= 2; /* Avid index */
1239 if (index < 0 || index >= s->nb_index_entries) {
1240 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1241 index_table->index_sid, s->index_start_position);
1242 return AVERROR_INVALIDDATA;
1245 offset_temp = s->stream_offset_entries[index];
1247 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1248 index_table->index_sid, s->index_start_position);
1249 return AVERROR_INVALIDDATA;
1253 *edit_unit_out = edit_unit;
1255 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1257 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1258 offset_temp += s->edit_unit_byte_count * s->index_duration;
1263 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);
1265 return AVERROR_INVALIDDATA;
1268 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1271 int8_t max_temporal_offset = -128;
1273 /* first compute how many entries we have */
1274 for (i = 0; i < index_table->nb_segments; i++) {
1275 MXFIndexTableSegment *s = index_table->segments[i];
1277 if (!s->nb_index_entries) {
1278 index_table->nb_ptses = 0;
1279 return 0; /* no TemporalOffsets */
1282 index_table->nb_ptses += s->index_duration;
1285 /* paranoid check */
1286 if (index_table->nb_ptses <= 0)
1289 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1290 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1291 av_freep(&index_table->ptses);
1292 return AVERROR(ENOMEM);
1295 /* we may have a few bad TemporalOffsets
1296 * make sure the corresponding PTSes don't have the bogus value 0 */
1297 for (x = 0; x < index_table->nb_ptses; x++)
1298 index_table->ptses[x] = AV_NOPTS_VALUE;
1312 * We want to transform it into this:
1323 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1324 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1325 * The latter makes DTS <= PTS.
1327 for (i = x = 0; i < index_table->nb_segments; i++) {
1328 MXFIndexTableSegment *s = index_table->segments[i];
1329 int index_delta = 1;
1330 int n = s->nb_index_entries;
1332 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1333 index_delta = 2; /* Avid index */
1334 /* ignore the last entry - it's the size of the essence container */
1338 for (j = 0; j < n; j += index_delta, x++) {
1339 int offset = s->temporal_offset_entries[j] / index_delta;
1340 int index = x + offset;
1342 if (x >= index_table->nb_ptses) {
1343 av_log(mxf->fc, AV_LOG_ERROR,
1344 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1345 s->nb_index_entries, s->index_duration);
1349 index_table->fake_index[x].timestamp = x;
1350 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1352 if (index < 0 || index >= index_table->nb_ptses) {
1353 av_log(mxf->fc, AV_LOG_ERROR,
1354 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1359 index_table->ptses[index] = x;
1360 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1364 index_table->first_dts = -max_temporal_offset;
1370 * Sorts and collects index table segments into index tables.
1371 * Also computes PTSes if possible.
1373 static int mxf_compute_index_tables(MXFContext *mxf)
1375 int i, j, k, ret, nb_sorted_segments;
1376 MXFIndexTableSegment **sorted_segments = NULL;
1378 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1379 nb_sorted_segments <= 0) {
1380 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1384 /* sanity check and count unique BodySIDs/IndexSIDs */
1385 for (i = 0; i < nb_sorted_segments; i++) {
1386 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1387 mxf->nb_index_tables++;
1388 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1389 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1390 ret = AVERROR_INVALIDDATA;
1391 goto finish_decoding_index;
1395 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1396 sizeof(*mxf->index_tables));
1397 if (!mxf->index_tables) {
1398 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1399 ret = AVERROR(ENOMEM);
1400 goto finish_decoding_index;
1403 /* distribute sorted segments to index tables */
1404 for (i = j = 0; i < nb_sorted_segments; i++) {
1405 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1410 mxf->index_tables[j].nb_segments++;
1413 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1414 MXFIndexTable *t = &mxf->index_tables[j];
1416 t->segments = av_mallocz_array(t->nb_segments,
1417 sizeof(*t->segments));
1420 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1421 " pointer array\n");
1422 ret = AVERROR(ENOMEM);
1423 goto finish_decoding_index;
1426 if (sorted_segments[i]->index_start_position)
1427 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1428 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1430 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1431 t->index_sid = sorted_segments[i]->index_sid;
1432 t->body_sid = sorted_segments[i]->body_sid;
1434 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1435 goto finish_decoding_index;
1437 /* fix zero IndexDurations */
1438 for (k = 0; k < t->nb_segments; k++) {
1439 if (t->segments[k]->index_duration)
1442 if (t->nb_segments > 1)
1443 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1446 if (mxf->fc->nb_streams <= 0) {
1447 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1451 /* assume the first stream's duration is reasonable
1452 * leave index_duration = 0 on further segments in case we have any (unlikely)
1454 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1460 finish_decoding_index:
1461 av_free(sorted_segments);
1465 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1467 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1468 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1469 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1470 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1473 static int mxf_uid_to_str(UID uid, char **str)
1477 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1479 return AVERROR(ENOMEM);
1480 for (i = 0; i < sizeof(UID); i++) {
1481 snprintf(p, 2 + 1, "%.2x", uid[i]);
1483 if (i == 3 || i == 5 || i == 7 || i == 9) {
1484 snprintf(p, 1 + 1, "-");
1491 static int mxf_add_uid_metadata(AVDictionary **pm, const char *key, UID uid)
1495 if ((ret = mxf_uid_to_str(uid, &str)) < 0)
1497 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1501 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1503 char buf[AV_TIMECODE_STR_SIZE];
1504 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1509 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1511 MXFStructuralComponent *component = NULL;
1512 MXFPulldownComponent *pulldown = NULL;
1514 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1518 switch (component->type) {
1519 case TimecodeComponent:
1520 return (MXFTimecodeComponent*)component;
1521 case PulldownComponent: /* timcode component may be located on a pulldown component */
1522 pulldown = (MXFPulldownComponent*)component;
1523 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1530 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1532 MXFPackage *package = NULL;
1535 for (i = 0; i < mxf->packages_count; i++) {
1536 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1540 if (!memcmp(package->package_uid, package_uid, 16))
1546 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1548 MXFDescriptor *sub_descriptor = NULL;
1554 if (descriptor->type == MultipleDescriptor) {
1555 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1556 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1558 if (!sub_descriptor) {
1559 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1562 if (sub_descriptor->linked_track_id == track_id) {
1563 return sub_descriptor;
1566 } else if (descriptor->type == Descriptor)
1572 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1574 MXFStructuralComponent *component = NULL;
1575 MXFPackage *package = NULL;
1576 MXFDescriptor *descriptor = NULL;
1579 if (!essence_group || !essence_group->structural_components_count)
1582 /* essence groups contains multiple representations of the same media,
1583 this return the first components with a valid Descriptor typically index 0 */
1584 for (i =0; i < essence_group->structural_components_count; i++){
1585 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1589 if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1592 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1599 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1601 MXFStructuralComponent *component = NULL;
1603 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1606 switch (component->type) {
1610 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1617 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1619 MXFPackage *physical_package = NULL;
1620 MXFTrack *physical_track = NULL;
1621 MXFStructuralComponent *sourceclip = NULL;
1622 MXFTimecodeComponent *mxf_tc = NULL;
1626 int64_t start_position;
1628 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1629 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1633 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1636 mxf_add_uid_metadata(&st->metadata, "reel_uid", physical_package->package_uid);
1638 /* the name of physical source package is name of the reel or tape */
1639 if (physical_package->name && physical_package->name[0])
1640 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1642 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1643 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1645 for (j = 0; j < physical_package->tracks_count; j++) {
1646 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1647 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1651 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1652 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1656 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1657 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1660 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1661 /* scale sourceclip start_position to match physical track edit rate */
1662 start_position = av_rescale_q(sourceclip->start_position,
1663 physical_track->edit_rate,
1664 source_track->edit_rate);
1666 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1667 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1677 static int mxf_parse_structural_metadata(MXFContext *mxf)
1679 MXFPackage *material_package = NULL;
1682 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1683 /* TODO: handle multiple material packages (OP3x) */
1684 for (i = 0; i < mxf->packages_count; i++) {
1685 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1686 if (material_package) break;
1688 if (!material_package) {
1689 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1690 return AVERROR_INVALIDDATA;
1693 mxf_add_uid_metadata(&mxf->fc->metadata, "material_package_uid", material_package->package_uid);
1694 if (material_package->name && material_package->name[0])
1695 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1697 for (i = 0; i < material_package->tracks_count; i++) {
1698 MXFPackage *source_package = NULL;
1699 MXFTrack *material_track = NULL;
1700 MXFTrack *source_track = NULL;
1701 MXFTrack *temp_track = NULL;
1702 MXFDescriptor *descriptor = NULL;
1703 MXFStructuralComponent *component = NULL;
1704 MXFTimecodeComponent *mxf_tc = NULL;
1705 UID *essence_container_ul = NULL;
1706 const MXFCodecUL *codec_ul = NULL;
1707 const MXFCodecUL *container_ul = NULL;
1708 const MXFCodecUL *pix_fmt_ul = NULL;
1713 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1714 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1718 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1719 mxf_tc = (MXFTimecodeComponent*)component;
1720 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1721 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1722 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1726 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1727 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1731 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1732 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1736 mxf_tc = (MXFTimecodeComponent*)component;
1737 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1738 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1739 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1744 /* TODO: handle multiple source clips */
1745 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1746 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1750 source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1751 if (!source_package) {
1752 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1755 for (k = 0; k < source_package->tracks_count; k++) {
1756 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1757 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1758 ret = AVERROR_INVALIDDATA;
1761 if (temp_track->track_id == component->source_track_id) {
1762 source_track = temp_track;
1766 if (!source_track) {
1767 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1771 if (!source_track || !component)
1774 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1775 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1776 ret = AVERROR_INVALIDDATA;
1780 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1781 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1782 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1783 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1787 st = avformat_new_stream(mxf->fc, NULL);
1789 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1790 ret = AVERROR(ENOMEM);
1793 st->id = source_track->track_id;
1794 st->priv_data = source_track;
1796 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1797 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1799 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1800 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1801 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1802 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1804 source_track->original_duration = st->duration = component->duration;
1806 if (st->duration == -1)
1807 st->duration = AV_NOPTS_VALUE;
1808 st->start_time = component->start_position;
1809 if (material_track->edit_rate.num <= 0 ||
1810 material_track->edit_rate.den <= 0) {
1811 av_log(mxf->fc, AV_LOG_WARNING,
1812 "Invalid edit rate (%d/%d) found on stream #%d, "
1813 "defaulting to 25/1\n",
1814 material_track->edit_rate.num,
1815 material_track->edit_rate.den, st->index);
1816 material_track->edit_rate = (AVRational){25, 1};
1818 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1820 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1821 * the former is accessible via st->priv_data */
1822 source_track->edit_rate = material_track->edit_rate;
1824 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1825 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1826 st->codec->codec_type = codec_ul->id;
1829 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1832 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1833 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1834 essence_container_ul = &descriptor->essence_container_ul;
1835 /* HACK: replacing the original key with mxf_encrypted_essence_container
1836 * is not allowed according to s429-6, try to find correct information anyway */
1837 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1838 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1839 for (k = 0; k < mxf->metadata_sets_count; k++) {
1840 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1841 if (metadata->type == CryptoContext) {
1842 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1848 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1849 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1850 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1851 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1852 avcodec_get_name(st->codec->codec_id));
1853 for (k = 0; k < 16; k++) {
1854 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1855 descriptor->essence_codec_ul[k]);
1856 if (!(k+1 & 19) || k == 5)
1857 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1859 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1861 mxf_add_uid_metadata(&st->metadata, "file_package_uid", source_package->package_uid);
1862 if (source_package->name && source_package->name[0])
1863 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
1865 mxf_parse_physical_source_package(mxf, source_track, st);
1867 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1868 source_track->intra_only = mxf_is_intra_only(descriptor);
1869 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1870 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1871 st->codec->codec_id = container_ul->id;
1872 st->codec->width = descriptor->width;
1873 st->codec->height = descriptor->height; /* Field height, not frame height */
1874 switch (descriptor->frame_layout) {
1875 case SegmentedFrame:
1876 /* This one is a weird layout I don't fully understand. */
1877 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1880 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1883 /* Every other line is stored and needs to be duplicated. */
1884 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1885 break; /* The correct thing to do here is fall through, but by breaking we might be
1886 able to decode some streams at half the vertical resolution, rather than not al all.
1887 It's also for compatibility with the old behavior. */
1890 case SeparateFields:
1891 switch (descriptor->field_dominance) {
1893 st->codec->field_order = AV_FIELD_TT;
1896 st->codec->field_order = AV_FIELD_BB;
1899 avpriv_request_sample(mxf->fc,
1900 "Field dominance %d support",
1901 descriptor->field_dominance);
1902 case 0: // we already have many samples with field_dominance == unknown
1905 /* Turn field height into frame height. */
1906 st->codec->height *= 2;
1909 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1911 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1912 st->codec->pix_fmt = descriptor->pix_fmt;
1913 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1914 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1915 &descriptor->essence_codec_ul);
1916 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1917 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1918 /* support files created before RP224v10 by defaulting to UYVY422
1919 if subsampling is 4:2:2 and component depth is 8-bit */
1920 if (descriptor->horiz_subsampling == 2 &&
1921 descriptor->vert_subsampling == 1 &&
1922 descriptor->component_depth == 8) {
1923 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1928 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1929 if (material_track->sequence->origin) {
1930 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1932 if (source_track->sequence->origin) {
1933 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1935 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1936 st->display_aspect_ratio = descriptor->aspect_ratio;
1937 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1938 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1939 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1940 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))
1941 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1942 st->codec->channels = descriptor->channels;
1943 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1945 if (descriptor->sample_rate.den > 0) {
1946 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1947 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1949 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1950 "found for stream #%d, time base forced to 1/48000\n",
1951 descriptor->sample_rate.num, descriptor->sample_rate.den,
1953 avpriv_set_pts_info(st, 64, 1, 48000);
1956 /* if duration is set, rescale it from EditRate to SampleRate */
1957 if (st->duration != AV_NOPTS_VALUE)
1958 st->duration = av_rescale_q(st->duration,
1959 av_inv_q(material_track->edit_rate),
1962 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1963 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1964 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1965 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1966 else if (descriptor->bits_per_sample == 32)
1967 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1968 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1969 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1970 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1971 else if (descriptor->bits_per_sample == 32)
1972 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1973 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1974 st->need_parsing = AVSTREAM_PARSE_FULL;
1976 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1977 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1978 essence_container_ul)->id;
1979 if (codec_id >= 0 &&
1980 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1981 av_dict_set(&st->metadata, "data_type",
1982 mxf_data_essence_descriptor[codec_id], 0);
1985 if (descriptor->extradata) {
1986 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1987 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1989 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1990 ret = ff_generate_avci_extradata(st);
1994 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1995 /* TODO: decode timestamps */
1996 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2005 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2007 struct tm time = { 0 };
2008 time.tm_year = (timestamp >> 48) - 1900;
2009 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2010 time.tm_mday = (timestamp >> 32 & 0xFF);
2011 time.tm_hour = (timestamp >> 24 & 0xFF);
2012 time.tm_min = (timestamp >> 16 & 0xFF);
2013 time.tm_sec = (timestamp >> 8 & 0xFF);
2015 /* msvcrt versions of strftime calls the invalid parameter handler
2016 * (aborting the process if one isn't set) if the parameters are out
2018 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2019 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2020 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2021 time.tm_min = av_clip(time.tm_min, 0, 59);
2022 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2024 *str = av_mallocz(32);
2026 return AVERROR(ENOMEM);
2027 if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2033 #define SET_STR_METADATA(pb, name, str) do { \
2034 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
2036 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2039 #define SET_UID_METADATA(pb, name, var, str) do { \
2040 avio_read(pb, var, 16); \
2041 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2043 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2046 #define SET_TS_METADATA(pb, name, var, str) do { \
2047 var = avio_rb64(pb); \
2048 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2050 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2053 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2055 MXFContext *mxf = arg;
2056 AVFormatContext *s = mxf->fc;
2063 SET_STR_METADATA(pb, "company_name", str);
2066 SET_STR_METADATA(pb, "product_name", str);
2069 SET_STR_METADATA(pb, "product_version", str);
2072 SET_UID_METADATA(pb, "product_uid", uid, str);
2075 SET_TS_METADATA(pb, "modification_date", ts, str);
2078 SET_STR_METADATA(pb, "application_platform", str);
2081 SET_UID_METADATA(pb, "generation_uid", uid, str);
2084 SET_UID_METADATA(pb, "uid", uid, str);
2090 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2091 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2092 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2093 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2094 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2095 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2096 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2097 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2098 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2099 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2100 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2101 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2102 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2103 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2104 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2105 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2106 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2107 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2108 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2109 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2110 { { 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 */
2111 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2112 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2113 { { 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 */
2114 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2115 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2116 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2117 { { 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 */
2118 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2119 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2120 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2121 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2122 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2123 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2124 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2125 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2128 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2131 case MultipleDescriptor:
2133 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2134 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2142 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2144 AVIOContext *pb = mxf->fc->pb;
2145 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2146 uint64_t klv_end = avio_tell(pb) + klv->length;
2149 return AVERROR(ENOMEM);
2150 mxf_metadataset_init(ctx, type);
2151 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2153 int tag = avio_rb16(pb);
2154 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2155 uint64_t next = avio_tell(pb) + size;
2158 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2159 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2160 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2163 if (tag > 0x7FFF) { /* dynamic tag */
2165 for (i = 0; i < mxf->local_tags_count; i++) {
2166 int local_tag = AV_RB16(mxf->local_tags+i*18);
2167 if (local_tag == tag) {
2168 memcpy(uid, mxf->local_tags+i*18+2, 16);
2169 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2170 PRINT_KEY(mxf->fc, "uid", uid);
2174 if (ctx_size && tag == 0x3C0A) {
2175 avio_read(pb, ctx->uid, 16);
2176 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2177 mxf_free_metadataset(&ctx);
2181 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2182 * it extending past the end of the KLV though (zzuf5.mxf). */
2183 if (avio_tell(pb) > klv_end) {
2186 mxf_free_metadataset(&ctx);
2189 av_log(mxf->fc, AV_LOG_ERROR,
2190 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2192 return AVERROR_INVALIDDATA;
2193 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2194 avio_seek(pb, next, SEEK_SET);
2196 if (ctx_size) ctx->type = type;
2197 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2201 * Matches any partition pack key, in other words:
2205 * @return non-zero if the key is a partition pack key, zero otherwise
2207 static int mxf_is_partition_pack_key(UID key)
2209 //NOTE: this is a little lax since it doesn't constraint key[14]
2210 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2211 key[13] >= 2 && key[13] <= 4;
2215 * Parses a metadata KLV
2216 * @return <0 on error, 0 otherwise
2218 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2219 int ctx_size, enum MXFMetadataSetType type)
2221 AVFormatContext *s = mxf->fc;
2223 if (klv.key[5] == 0x53) {
2224 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2226 uint64_t next = avio_tell(s->pb) + klv.length;
2227 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2229 /* only seek forward, else this can loop for a long time */
2230 if (avio_tell(s->pb) > next) {
2231 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2233 return AVERROR_INVALIDDATA;
2236 avio_seek(s->pb, next, SEEK_SET);
2239 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2246 * Seeks to the previous partition and parses it, if possible
2247 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2249 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2251 AVIOContext *pb = mxf->fc->pb;
2253 int64_t current_partition_ofs;
2256 if (!mxf->current_partition ||
2257 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2258 return 0; /* we've parsed all partitions */
2260 /* seek to previous partition */
2261 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2262 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2263 mxf->current_partition = NULL;
2265 av_dlog(mxf->fc, "seeking to previous partition\n");
2267 /* Make sure this is actually a PartitionPack, and if so parse it.
2270 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2271 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2275 if (!mxf_is_partition_pack_key(klv.key)) {
2276 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2277 return AVERROR_INVALIDDATA;
2280 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2281 * can point to just before the current partition, causing klv_read_packet()
2282 * to sync back up to it. See deadlock3.mxf
2284 if (klv.offset >= current_partition_ofs) {
2285 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2286 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2287 return AVERROR_INVALIDDATA;
2290 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2297 * Called when essence is encountered
2298 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2300 static int mxf_parse_handle_essence(MXFContext *mxf)
2302 AVIOContext *pb = mxf->fc->pb;
2305 if (mxf->parsing_backward) {
2306 return mxf_seek_to_previous_partition(mxf);
2308 if (!mxf->footer_partition) {
2309 av_dlog(mxf->fc, "no FooterPartition\n");
2313 av_dlog(mxf->fc, "seeking to FooterPartition\n");
2315 /* remember where we were so we don't end up seeking further back than this */
2316 mxf->last_forward_tell = avio_tell(pb);
2318 if (!pb->seekable) {
2319 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2323 /* seek to FooterPartition and parse backward */
2324 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2325 av_log(mxf->fc, AV_LOG_ERROR,
2326 "failed to seek to FooterPartition @ 0x%" PRIx64
2327 " (%"PRId64") - partial file?\n",
2328 mxf->run_in + mxf->footer_partition, ret);
2332 mxf->current_partition = NULL;
2333 mxf->parsing_backward = 1;
2340 * Called when the next partition or EOF is encountered
2341 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2343 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2345 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2349 * Figures out the proper offset and length of the essence container in each partition
2351 static void mxf_compute_essence_containers(MXFContext *mxf)
2355 /* everything is already correct */
2356 if (mxf->op == OPAtom)
2359 for (x = 0; x < mxf->partitions_count; x++) {
2360 MXFPartition *p = &mxf->partitions[x];
2363 continue; /* BodySID == 0 -> no essence */
2365 if (x >= mxf->partitions_count - 1)
2366 break; /* FooterPartition - can't compute length (and we don't need to) */
2368 /* essence container spans to the next partition */
2369 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2371 if (p->essence_length < 0) {
2372 /* next ThisPartition < essence_offset */
2373 p->essence_length = 0;
2374 av_log(mxf->fc, AV_LOG_ERROR,
2375 "partition %i: bad ThisPartition = %"PRIX64"\n",
2376 x+1, mxf->partitions[x+1].this_partition);
2381 static int64_t round_to_kag(int64_t position, int kag_size)
2383 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2384 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2385 int64_t ret = (position / kag_size) * kag_size;
2386 return ret == position ? ret : ret + kag_size;
2389 static int is_pcm(enum AVCodecID codec_id)
2391 /* we only care about "normal" PCM codecs until we get samples */
2392 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2396 * Deal with the case where for some audio atoms EditUnitByteCount is
2397 * very small (2, 4..). In those cases we should read more than one
2398 * sample per call to mxf_read_packet().
2400 static void mxf_handle_small_eubc(AVFormatContext *s)
2402 MXFContext *mxf = s->priv_data;
2404 /* assuming non-OPAtom == frame wrapped
2405 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2406 if (mxf->op != OPAtom)
2409 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2410 if (s->nb_streams != 1 ||
2411 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2412 !is_pcm(s->streams[0]->codec->codec_id) ||
2413 mxf->nb_index_tables != 1 ||
2414 mxf->index_tables[0].nb_segments != 1 ||
2415 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2418 /* arbitrarily default to 48 kHz PAL audio frame size */
2419 /* TODO: We could compute this from the ratio between the audio
2420 * and video edit rates for 48 kHz NTSC we could use the
2421 * 1802-1802-1802-1802-1801 pattern. */
2422 mxf->edit_units_per_packet = 1920;
2425 static void mxf_read_random_index_pack(AVFormatContext *s)
2427 MXFContext *mxf = s->priv_data;
2429 int64_t file_size, max_rip_length, min_rip_length;
2432 if (!s->pb->seekable)
2435 file_size = avio_size(s->pb);
2437 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2438 * The limit below assumes a file with nothing but partition packs and a RIP.
2439 * Before changing this, consider that a muxer may place each sample in its own partition.
2441 * 105 is the size of the smallest possible PartitionPack
2442 * 12 is the size of each RIP entry
2443 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2445 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2446 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2448 /* We're only interested in RIPs with at least two entries.. */
2449 min_rip_length = 16+1+24+4;
2451 /* See S377m section 11 */
2452 avio_seek(s->pb, file_size - 4, SEEK_SET);
2453 length = avio_rb32(s->pb);
2455 if (length < min_rip_length || length > max_rip_length)
2457 avio_seek(s->pb, file_size - length, SEEK_SET);
2458 if (klv_read_packet(&klv, s->pb) < 0 ||
2459 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2460 klv.length != length - 20)
2463 avio_skip(s->pb, klv.length - 12);
2464 mxf->footer_partition = avio_rb64(s->pb);
2467 if (mxf->run_in + mxf->footer_partition >= file_size) {
2468 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2469 mxf->footer_partition = 0;
2473 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2476 static int mxf_read_header(AVFormatContext *s)
2478 MXFContext *mxf = s->priv_data;
2480 int64_t essence_offset = 0;
2483 mxf->last_forward_tell = INT64_MAX;
2484 mxf->edit_units_per_packet = 1;
2486 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2487 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2488 return AVERROR_INVALIDDATA;
2490 avio_seek(s->pb, -14, SEEK_CUR);
2492 mxf->run_in = avio_tell(s->pb);
2494 mxf_read_random_index_pack(s);
2496 while (!avio_feof(s->pb)) {
2497 const MXFMetadataReadTableEntry *metadata;
2499 if (klv_read_packet(&klv, s->pb) < 0) {
2500 /* EOF - seek to previous partition or stop */
2501 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2507 PRINT_KEY(s, "read header", klv.key);
2508 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2509 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2510 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2511 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2512 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2514 if (!mxf->current_partition) {
2515 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2516 return AVERROR_INVALIDDATA;
2519 if (!mxf->current_partition->essence_offset) {
2520 /* for OP1a we compute essence_offset
2521 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2522 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2523 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2525 int64_t op1a_essence_offset =
2526 round_to_kag(mxf->current_partition->this_partition +
2527 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2528 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2529 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2531 if (mxf->op == OPAtom) {
2532 /* point essence_offset to the actual data
2533 * OPAtom has all the essence in one big KLV
2535 mxf->current_partition->essence_offset = avio_tell(s->pb);
2536 mxf->current_partition->essence_length = klv.length;
2538 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2539 mxf->current_partition->essence_offset = op1a_essence_offset;
2543 if (!essence_offset)
2544 essence_offset = klv.offset;
2546 /* seek to footer, previous partition or stop */
2547 if (mxf_parse_handle_essence(mxf) <= 0)
2550 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2551 /* next partition pack - keep going, seek to previous partition or stop */
2552 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2554 else if (mxf->parsing_backward)
2556 /* we're still parsing forward. proceed to parsing this partition pack */
2559 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2560 if (IS_KLV_KEY(klv.key, metadata->key)) {
2561 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2565 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2569 if (!metadata->read)
2570 avio_skip(s->pb, klv.length);
2572 /* FIXME avoid seek */
2573 if (!essence_offset) {
2574 av_log(s, AV_LOG_ERROR, "no essence\n");
2575 ret = AVERROR_INVALIDDATA;
2578 avio_seek(s->pb, essence_offset, SEEK_SET);
2580 mxf_compute_essence_containers(mxf);
2582 /* we need to do this before computing the index tables
2583 * to be able to fill in zero IndexDurations with st->duration */
2584 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2587 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2590 if (mxf->nb_index_tables > 1) {
2591 /* TODO: look up which IndexSID to use via EssenceContainerData */
2592 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2593 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2594 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2595 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2596 ret = AVERROR_INVALIDDATA;
2600 mxf_handle_small_eubc(s);
2610 * Sets mxf->current_edit_unit based on what offset we're currently at.
2611 * @return next_ofs if OK, <0 on error
2613 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2615 int64_t last_ofs = -1, next_ofs = -1;
2616 MXFIndexTable *t = &mxf->index_tables[0];
2618 /* this is called from the OP1a demuxing logic, which means there
2619 * may be no index tables */
2620 if (mxf->nb_index_tables <= 0)
2623 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2624 while (mxf->current_edit_unit >= 0) {
2625 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2628 if (next_ofs <= last_ofs) {
2629 /* large next_ofs didn't change or current_edit_unit wrapped
2630 * around this fixes the infinite loop on zzuf3.mxf */
2631 av_log(mxf->fc, AV_LOG_ERROR,
2632 "next_ofs didn't change. not deriving packet timestamps\n");
2636 if (next_ofs > current_offset)
2639 last_ofs = next_ofs;
2640 mxf->current_edit_unit++;
2643 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2644 if (mxf->current_edit_unit < 0)
2650 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2651 uint64_t *sample_count)
2653 int i, total = 0, size = 0;
2654 AVStream *st = mxf->fc->streams[stream_index];
2655 MXFTrack *track = st->priv_data;
2656 AVRational time_base = av_inv_q(track->edit_rate);
2657 AVRational sample_rate = av_inv_q(st->time_base);
2658 const MXFSamplesPerFrame *spf = NULL;
2660 if ((sample_rate.num / sample_rate.den) == 48000)
2661 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2663 int remainder = (sample_rate.num * time_base.num) %
2664 (time_base.den * sample_rate.den);
2665 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2666 av_mul_q(sample_rate, time_base)));
2668 av_log(mxf->fc, AV_LOG_WARNING,
2669 "seeking detected on stream #%d with time base (%d/%d) and "
2670 "sample rate (%d/%d), audio pts won't be accurate.\n",
2671 stream_index, time_base.num, time_base.den,
2672 sample_rate.num, sample_rate.den);
2676 while (spf->samples_per_frame[size]) {
2677 total += spf->samples_per_frame[size];
2683 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2684 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2685 *sample_count += spf->samples_per_frame[i];
2691 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2694 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2695 int64_t bits_per_sample = codec->bits_per_coded_sample;
2697 if (!bits_per_sample)
2698 bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2700 pkt->pts = track->sample_count;
2702 if ( codec->channels <= 0
2703 || bits_per_sample <= 0
2704 || codec->channels * (int64_t)bits_per_sample < 8)
2705 return AVERROR(EINVAL);
2706 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2710 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2713 MXFContext *mxf = s->priv_data;
2716 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2717 PRINT_KEY(s, "read packet", klv.key);
2718 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2719 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2720 ret = mxf_decrypt_triplet(s, pkt, &klv);
2722 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2727 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2728 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2729 int index = mxf_get_stream_index(s, &klv);
2730 int64_t next_ofs, next_klv;
2733 AVCodecContext *codec;
2736 av_log(s, AV_LOG_ERROR,
2737 "error getting stream index %"PRIu32"\n",
2738 AV_RB32(klv.key + 12));
2742 st = s->streams[index];
2743 track = st->priv_data;
2745 if (s->streams[index]->discard == AVDISCARD_ALL)
2748 next_klv = avio_tell(s->pb) + klv.length;
2749 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2751 if (next_ofs >= 0 && next_klv > next_ofs) {
2752 /* if this check is hit then it's possible OPAtom was treated as OP1a
2753 * truncate the packet since it's probably very large (>2 GiB is common) */
2754 avpriv_request_sample(s,
2755 "OPAtom misinterpreted as OP1a?"
2756 "KLV for edit unit %i extending into "
2758 mxf->current_edit_unit);
2759 klv.length = next_ofs - avio_tell(s->pb);
2762 /* check for 8 channels AES3 element */
2763 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2764 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2767 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2771 ret = av_get_packet(s->pb, pkt, klv.length);
2775 pkt->stream_index = index;
2776 pkt->pos = klv.offset;
2780 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2781 /* mxf->current_edit_unit good - see if we have an
2782 * index table to derive timestamps from */
2783 MXFIndexTable *t = &mxf->index_tables[0];
2785 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2786 pkt->dts = mxf->current_edit_unit + t->first_dts;
2787 pkt->pts = t->ptses[mxf->current_edit_unit];
2788 } else if (track->intra_only) {
2789 /* intra-only -> PTS = EditUnit.
2790 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2791 pkt->pts = mxf->current_edit_unit;
2793 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2794 ret = mxf_set_audio_pts(mxf, codec, pkt);
2799 /* seek for truncated packets */
2800 avio_seek(s->pb, next_klv, SEEK_SET);
2805 avio_skip(s->pb, klv.length);
2807 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2810 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2812 MXFContext *mxf = s->priv_data;
2814 int64_t ret64, pos, next_pos;
2819 if (mxf->op != OPAtom)
2820 return mxf_read_packet_old(s, pkt);
2822 /* OPAtom - clip wrapped demuxing */
2823 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2825 t = &mxf->index_tables[0];
2827 if (mxf->current_edit_unit >= st->duration)
2830 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2832 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2835 /* compute size by finding the next edit unit or the end of the essence container
2836 * not pretty, but it works */
2837 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2838 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2839 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2840 return AVERROR_INVALIDDATA;
2843 if ((size = next_pos - pos) <= 0) {
2844 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2845 return AVERROR_INVALIDDATA;
2848 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2851 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2854 pkt->stream_index = 0;
2856 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2857 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2858 pkt->dts = mxf->current_edit_unit + t->first_dts;
2859 pkt->pts = t->ptses[mxf->current_edit_unit];
2860 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2861 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2866 mxf->current_edit_unit += edit_units;
2871 static int mxf_read_close(AVFormatContext *s)
2873 MXFContext *mxf = s->priv_data;
2876 av_freep(&mxf->packages_refs);
2878 for (i = 0; i < s->nb_streams; i++)
2879 s->streams[i]->priv_data = NULL;
2881 for (i = 0; i < mxf->metadata_sets_count; i++) {
2882 mxf_free_metadataset(mxf->metadata_sets + i);
2884 av_freep(&mxf->partitions);
2885 av_freep(&mxf->metadata_sets);
2886 av_freep(&mxf->aesc);
2887 av_freep(&mxf->local_tags);
2889 if (mxf->index_tables) {
2890 for (i = 0; i < mxf->nb_index_tables; i++) {
2891 av_freep(&mxf->index_tables[i].segments);
2892 av_freep(&mxf->index_tables[i].ptses);
2893 av_freep(&mxf->index_tables[i].fake_index);
2896 av_freep(&mxf->index_tables);
2901 static int mxf_probe(AVProbeData *p) {
2902 const uint8_t *bufp = p->buf;
2903 const uint8_t *end = p->buf + p->buf_size;
2905 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2908 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2909 end -= sizeof(mxf_header_partition_pack_key);
2911 for (; bufp < end;) {
2912 if (!((bufp[13] - 1) & 0xF2)){
2913 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2914 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2915 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2916 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2917 return AVPROBE_SCORE_MAX;
2926 /* rudimentary byte seek */
2927 /* XXX: use MXF Index */
2928 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2930 AVStream *st = s->streams[stream_index];
2932 MXFContext* mxf = s->priv_data;
2936 MXFTrack *source_track = st->priv_data;
2938 /* if audio then truncate sample_time to EditRate */
2939 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2940 sample_time = av_rescale_q(sample_time, st->time_base,
2941 av_inv_q(source_track->edit_rate));
2943 if (mxf->nb_index_tables <= 0) {
2945 return AVERROR_INVALIDDATA;
2946 if (sample_time < 0)
2948 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2950 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2954 ff_update_cur_dts(s, st, sample_time);
2955 mxf->current_edit_unit = sample_time;
2957 t = &mxf->index_tables[0];
2959 /* clamp above zero, else ff_index_search_timestamp() returns negative
2960 * this also means we allow seeking before the start */
2961 sample_time = FFMAX(sample_time, 0);
2963 if (t->fake_index) {
2964 /* behave as if we have a proper index */
2965 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2968 /* no IndexEntryArray (one or more CBR segments)
2969 * make sure we don't seek past the end */
2970 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2973 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2976 ff_update_cur_dts(s, st, sample_time);
2977 mxf->current_edit_unit = sample_time;
2978 avio_seek(s->pb, seekpos, SEEK_SET);
2981 // Update all tracks sample count
2982 for (i = 0; i < s->nb_streams; i++) {
2983 AVStream *cur_st = s->streams[i];
2984 MXFTrack *cur_track = cur_st->priv_data;
2985 uint64_t current_sample_count = 0;
2986 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2987 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2991 cur_track->sample_count = current_sample_count;
2997 AVInputFormat ff_mxf_demuxer = {
2999 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3000 .priv_data_size = sizeof(MXFContext),
3001 .read_probe = mxf_probe,
3002 .read_header = mxf_read_header,
3003 .read_packet = mxf_read_packet,
3004 .read_close = mxf_read_close,
3005 .read_seek = mxf_read_seek,