3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
33 * Search for Track numbers which will identify essence element KLV packets.
34 * Search for SourcePackage which define tracks which contains Track numbers.
35 * Material Package contains tracks with reference to SourcePackage tracks.
36 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37 * Assign Descriptors to correct Tracks.
39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40 * Metadata parsing resolves Strong References to objects.
42 * Simple demuxer, only OP1A supported and some files might not work at all.
43 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/timecode.h"
75 OPSONYOpt, /* FATE sample, violates the spec in places */
78 typedef struct MXFPartition {
81 MXFPartitionType type;
82 uint64_t previous_partition;
85 int64_t this_partition;
86 int64_t essence_offset; ///< absolute offset of essence
87 int64_t essence_length;
89 int64_t header_byte_count;
90 int64_t index_byte_count;
92 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
95 typedef struct MXFCryptoContext {
97 enum MXFMetadataSetType type;
98 UID source_container_ul;
101 typedef struct MXFStructuralComponent {
103 enum MXFMetadataSetType type;
104 UID source_package_uid;
105 UID data_definition_ul;
107 int64_t start_position;
109 } MXFStructuralComponent;
111 typedef struct MXFSequence {
113 enum MXFMetadataSetType type;
114 UID data_definition_ul;
115 UID *structural_components_refs;
116 int structural_components_count;
121 typedef struct MXFTrack {
123 enum MXFMetadataSetType type;
126 struct AVRational rate;
128 } MXFTimecodeComponent;
132 enum MXFMetadataSetType type;
133 UID input_segment_ref;
134 } MXFPulldownComponent;
138 enum MXFMetadataSetType type;
139 UID *structural_components_refs;
140 int structural_components_count;
146 enum MXFMetadataSetType type;
147 MXFSequence *sequence; /* mandatory, and only one */
150 uint8_t track_number[4];
151 AVRational edit_rate;
153 uint64_t sample_count;
154 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
157 typedef struct MXFDescriptor {
159 enum MXFMetadataSetType type;
160 UID essence_container_ul;
161 UID essence_codec_ul;
162 AVRational sample_rate;
163 AVRational aspect_ratio;
165 int height; /* Field height, not frame height */
166 int frame_layout; /* See MXFFrameLayout enum */
172 int64_t duration; /* ContainerDuration optional property */
173 unsigned int component_depth;
174 unsigned int horiz_subsampling;
175 unsigned int vert_subsampling;
176 UID *sub_descriptors_refs;
177 int sub_descriptors_count;
181 enum AVPixelFormat pix_fmt;
184 typedef struct MXFIndexTableSegment {
186 enum MXFMetadataSetType type;
187 int edit_unit_byte_count;
190 AVRational index_edit_rate;
191 uint64_t index_start_position;
192 uint64_t index_duration;
193 int8_t *temporal_offset_entries;
195 uint64_t *stream_offset_entries;
196 int nb_index_entries;
197 } MXFIndexTableSegment;
199 typedef struct MXFPackage {
201 enum MXFMetadataSetType type;
206 MXFDescriptor *descriptor; /* only one */
211 typedef struct MXFMetadataSet {
213 enum MXFMetadataSetType type;
216 /* decoded index table */
217 typedef struct MXFIndexTable {
220 int nb_ptses; /* number of PTSes or total duration of index */
221 int64_t first_dts; /* DTS = EditUnit + first_dts */
222 int64_t *ptses; /* maps EditUnit -> PTS */
224 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
225 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
228 typedef struct MXFContext {
229 MXFPartition *partitions;
230 unsigned partitions_count;
234 MXFMetadataSet **metadata_sets;
235 int metadata_sets_count;
239 int local_tags_count;
240 uint64_t footer_partition;
241 KLVPacket current_klv_data;
242 int current_klv_index;
244 MXFPartition *current_partition;
245 int parsing_backward;
246 int64_t last_forward_tell;
247 int last_forward_partition;
248 int current_edit_unit;
250 MXFIndexTable *index_tables;
251 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
254 enum MXFWrappingScheme {
259 /* NOTE: klv_offset is not set (-1) for local keys */
260 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
262 typedef struct MXFMetadataReadTableEntry {
264 MXFMetadataReadFunc *read;
266 enum MXFMetadataSetType type;
267 } MXFMetadataReadTableEntry;
269 static int mxf_read_close(AVFormatContext *s);
271 /* partial keys to match */
272 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
273 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
274 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
275 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
276 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
277 /* complete keys to match */
278 static const uint8_t mxf_crypto_source_container_ul[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x09,0x06,0x01,0x01,0x02,0x02,0x00,0x00,0x00 };
279 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
280 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
281 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
282 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
283 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
284 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
286 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
288 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
290 MXFIndexTableSegment *seg;
291 switch ((*ctx)->type) {
293 av_freep(&((MXFDescriptor *)*ctx)->extradata);
295 case MultipleDescriptor:
296 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
299 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
302 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
305 case MaterialPackage:
306 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
307 av_freep(&((MXFPackage *)*ctx)->name);
309 case IndexTableSegment:
310 seg = (MXFIndexTableSegment *)*ctx;
311 av_freep(&seg->temporal_offset_entries);
312 av_freep(&seg->flag_entries);
313 av_freep(&seg->stream_offset_entries);
321 static int64_t klv_decode_ber_length(AVIOContext *pb)
323 uint64_t size = avio_r8(pb);
324 if (size & 0x80) { /* long form */
325 int bytes_num = size & 0x7f;
326 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
328 return AVERROR_INVALIDDATA;
331 size = size << 8 | avio_r8(pb);
336 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
339 for (i = 0; i < size && !avio_feof(pb); i++) {
343 else if (b != key[i])
349 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
351 if (!mxf_read_sync(pb, mxf_klv_key, 4))
352 return AVERROR_INVALIDDATA;
353 klv->offset = avio_tell(pb) - 4;
354 memcpy(klv->key, mxf_klv_key, 4);
355 avio_read(pb, klv->key + 4, 12);
356 klv->length = klv_decode_ber_length(pb);
357 return klv->length == -1 ? -1 : 0;
360 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
364 for (i = 0; i < s->nb_streams; i++) {
365 MXFTrack *track = s->streams[i]->priv_data;
367 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
370 /* return 0 if only one stream, for OP Atom files with 0 as track number */
371 return s->nb_streams == 1 ? 0 : -1;
374 /* XXX: use AVBitStreamFilter */
375 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
377 const uint8_t *buf_ptr, *end_ptr;
381 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
382 return AVERROR_INVALIDDATA;
383 length = av_get_packet(pb, pkt, length);
386 data_ptr = pkt->data;
387 end_ptr = pkt->data + length;
388 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
389 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
390 for (i = 0; i < st->codec->channels; i++) {
391 uint32_t sample = bytestream_get_le32(&buf_ptr);
392 if (st->codec->bits_per_coded_sample == 24)
393 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
395 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
397 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
399 av_shrink_packet(pkt, data_ptr - pkt->data);
403 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
405 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
406 MXFContext *mxf = s->priv_data;
407 AVIOContext *pb = s->pb;
408 int64_t end = avio_tell(pb) + klv->length;
411 uint64_t plaintext_size;
416 if (!mxf->aesc && s->key && s->keylen == 16) {
417 mxf->aesc = av_aes_alloc();
419 return AVERROR(ENOMEM);
420 av_aes_init(mxf->aesc, s->key, 128, 1);
423 avio_skip(pb, klv_decode_ber_length(pb));
425 klv_decode_ber_length(pb);
426 plaintext_size = avio_rb64(pb);
428 klv_decode_ber_length(pb);
429 avio_read(pb, klv->key, 16);
430 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
431 return AVERROR_INVALIDDATA;
432 index = mxf_get_stream_index(s, klv);
434 return AVERROR_INVALIDDATA;
436 klv_decode_ber_length(pb);
437 orig_size = avio_rb64(pb);
438 if (orig_size < plaintext_size)
439 return AVERROR_INVALIDDATA;
441 size = klv_decode_ber_length(pb);
442 if (size < 32 || size - 32 < orig_size)
443 return AVERROR_INVALIDDATA;
444 avio_read(pb, ivec, 16);
445 avio_read(pb, tmpbuf, 16);
447 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
448 if (memcmp(tmpbuf, checkv, 16))
449 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
451 size = av_get_packet(pb, pkt, size);
454 else if (size < plaintext_size)
455 return AVERROR_INVALIDDATA;
456 size -= plaintext_size;
458 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
459 &pkt->data[plaintext_size], size >> 4, ivec, 1);
460 av_shrink_packet(pkt, orig_size);
461 pkt->stream_index = index;
462 avio_skip(pb, end - avio_tell(pb));
466 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
468 MXFContext *mxf = arg;
469 int item_num = avio_rb32(pb);
470 int item_len = avio_rb32(pb);
472 if (item_len != 18) {
473 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
474 return AVERROR_PATCHWELCOME;
476 if (item_num > 65536) {
477 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
478 return AVERROR_INVALIDDATA;
481 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
482 av_free(mxf->local_tags);
483 mxf->local_tags_count = 0;
484 mxf->local_tags = av_calloc(item_num, item_len);
485 if (!mxf->local_tags)
486 return AVERROR(ENOMEM);
487 mxf->local_tags_count = item_num;
488 avio_read(pb, mxf->local_tags, item_num*item_len);
492 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
494 MXFContext *mxf = arg;
495 MXFPartition *partition, *tmp_part;
497 uint64_t footer_partition;
498 uint32_t nb_essence_containers;
500 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
502 return AVERROR(ENOMEM);
503 mxf->partitions = tmp_part;
505 if (mxf->parsing_backward) {
506 /* insert the new partition pack in the middle
507 * this makes the entries in mxf->partitions sorted by offset */
508 memmove(&mxf->partitions[mxf->last_forward_partition+1],
509 &mxf->partitions[mxf->last_forward_partition],
510 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
511 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
513 mxf->last_forward_partition++;
514 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
517 memset(partition, 0, sizeof(*partition));
518 mxf->partitions_count++;
519 partition->pack_length = avio_tell(pb) - klv_offset + size;
520 partition->pack_ofs = klv_offset;
524 partition->type = Header;
527 partition->type = BodyPartition;
530 partition->type = Footer;
533 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
534 return AVERROR_INVALIDDATA;
537 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
538 partition->closed = partition->type == Footer || !(uid[14] & 1);
539 partition->complete = uid[14] > 2;
541 partition->kag_size = avio_rb32(pb);
542 partition->this_partition = avio_rb64(pb);
543 partition->previous_partition = avio_rb64(pb);
544 footer_partition = avio_rb64(pb);
545 partition->header_byte_count = avio_rb64(pb);
546 partition->index_byte_count = avio_rb64(pb);
547 partition->index_sid = avio_rb32(pb);
549 partition->body_sid = avio_rb32(pb);
550 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
551 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
552 return AVERROR_INVALIDDATA;
554 nb_essence_containers = avio_rb32(pb);
556 if (partition->this_partition &&
557 partition->previous_partition == partition->this_partition) {
558 av_log(mxf->fc, AV_LOG_ERROR,
559 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
560 partition->previous_partition);
561 /* override with the actual previous partition offset */
562 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
564 mxf->partitions + mxf->last_forward_partition - 2;
565 partition->previous_partition = prev->this_partition;
567 /* if no previous body partition are found point to the header
569 if (partition->previous_partition == partition->this_partition)
570 partition->previous_partition = 0;
571 av_log(mxf->fc, AV_LOG_ERROR,
572 "Overriding PreviousPartition with %"PRIx64"\n",
573 partition->previous_partition);
576 /* some files don'thave FooterPartition set in every partition */
577 if (footer_partition) {
578 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
579 av_log(mxf->fc, AV_LOG_ERROR,
580 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
581 mxf->footer_partition, footer_partition);
583 mxf->footer_partition = footer_partition;
588 "PartitionPack: ThisPartition = 0x%"PRIX64
589 ", PreviousPartition = 0x%"PRIX64", "
590 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
591 partition->this_partition,
592 partition->previous_partition, footer_partition,
593 partition->index_sid, partition->body_sid);
595 /* sanity check PreviousPartition if set */
596 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
597 if (partition->previous_partition &&
598 mxf->run_in + partition->previous_partition >= klv_offset) {
599 av_log(mxf->fc, AV_LOG_ERROR,
600 "PreviousPartition points to this partition or forward\n");
601 return AVERROR_INVALIDDATA;
604 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
605 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
606 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
607 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
608 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
609 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
610 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
611 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
612 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
613 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
614 else if (op[12] == 0x10) {
615 /* SMPTE 390m: "There shall be exactly one essence container"
616 * The following block deals with files that violate this, namely:
617 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
618 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
619 if (nb_essence_containers != 1) {
620 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
624 av_log(mxf->fc, AV_LOG_WARNING,
625 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
626 nb_essence_containers,
627 op == OP1a ? "OP1a" : "OPAtom");
633 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
637 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
638 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
639 partition->kag_size);
641 if (mxf->op == OPSONYOpt)
642 partition->kag_size = 512;
644 partition->kag_size = 1;
646 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
652 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
654 MXFMetadataSet **tmp;
656 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
658 return AVERROR(ENOMEM);
659 mxf->metadata_sets = tmp;
660 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
661 mxf->metadata_sets_count++;
665 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
667 MXFCryptoContext *cryptocontext = arg;
669 return AVERROR_INVALIDDATA;
670 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
671 avio_read(pb, cryptocontext->source_container_ul, 16);
675 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
677 *count = avio_rb32(pb);
678 *refs = av_calloc(*count, sizeof(UID));
681 return AVERROR(ENOMEM);
683 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
684 avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
688 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
690 MXFContext *mxf = arg;
693 if (mxf->packages_refs)
694 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
695 av_free(mxf->packages_refs);
696 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
701 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
703 MXFStructuralComponent *source_clip = arg;
706 source_clip->duration = avio_rb64(pb);
709 source_clip->start_position = avio_rb64(pb);
712 /* UMID, only get last 16 bytes */
714 avio_read(pb, source_clip->source_package_uid, 16);
717 source_clip->source_track_id = avio_rb32(pb);
723 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
725 MXFTimecodeComponent *mxf_timecode = arg;
728 mxf_timecode->start_frame = avio_rb64(pb);
731 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
734 mxf_timecode->drop_frame = avio_r8(pb);
740 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
742 MXFPulldownComponent *mxf_pulldown = arg;
745 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
751 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
753 MXFTrack *track = arg;
756 track->track_id = avio_rb32(pb);
759 avio_read(pb, track->track_number, 4);
762 track->edit_rate.num = avio_rb32(pb);
763 track->edit_rate.den = avio_rb32(pb);
766 avio_read(pb, track->sequence_ref, 16);
772 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
774 MXFSequence *sequence = arg;
777 sequence->duration = avio_rb64(pb);
780 avio_read(pb, sequence->data_definition_ul, 16);
783 sequence->origin = avio_r8(pb);
786 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
787 &sequence->structural_components_count);
792 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
794 MXFEssenceGroup *essence_group = arg;
797 essence_group->duration = avio_rb64(pb);
800 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
801 &essence_group->structural_components_count);
806 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
812 return AVERROR(EINVAL);
814 buf_size = size + size / 2 + 1;
815 *str = av_malloc(buf_size);
817 return AVERROR(ENOMEM);
819 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
827 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
829 MXFPackage *package = arg;
832 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
833 &package->tracks_count);
836 avio_read(pb, package->package_ul, 16);
837 avio_read(pb, package->package_uid, 16);
840 avio_read(pb, package->descriptor_ref, 16);
843 return mxf_read_utf16_string(pb, size, &package->name);
848 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
852 segment->nb_index_entries = avio_rb32(pb);
854 length = avio_rb32(pb);
856 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
857 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
858 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
859 av_freep(&segment->temporal_offset_entries);
860 av_freep(&segment->flag_entries);
861 return AVERROR(ENOMEM);
864 for (i = 0; i < segment->nb_index_entries; i++) {
865 segment->temporal_offset_entries[i] = avio_r8(pb);
866 avio_r8(pb); /* KeyFrameOffset */
867 segment->flag_entries[i] = avio_r8(pb);
868 segment->stream_offset_entries[i] = avio_rb64(pb);
869 avio_skip(pb, length - 11);
874 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
876 MXFIndexTableSegment *segment = arg;
879 segment->edit_unit_byte_count = avio_rb32(pb);
880 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
883 segment->index_sid = avio_rb32(pb);
884 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
887 segment->body_sid = avio_rb32(pb);
888 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
891 av_dlog(NULL, "IndexEntryArray found\n");
892 return mxf_read_index_entry_array(pb, segment);
894 segment->index_edit_rate.num = avio_rb32(pb);
895 segment->index_edit_rate.den = avio_rb32(pb);
896 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
897 segment->index_edit_rate.den);
900 segment->index_start_position = avio_rb64(pb);
901 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
904 segment->index_duration = avio_rb64(pb);
905 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
911 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
913 int code, value, ofs = 0;
914 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
919 av_dlog(NULL, "pixel layout: code %#x\n", code);
922 layout[ofs++] = code;
923 layout[ofs++] = value;
925 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
926 } while (code != 0); /* SMPTE 377M E.2.46 */
928 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
931 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
933 MXFDescriptor *descriptor = arg;
936 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
937 &descriptor->sub_descriptors_count);
938 case 0x3002: /* ContainerDuration */
939 descriptor->duration = avio_rb64(pb);
942 avio_read(pb, descriptor->essence_container_ul, 16);
945 descriptor->linked_track_id = avio_rb32(pb);
947 case 0x3201: /* PictureEssenceCoding */
948 avio_read(pb, descriptor->essence_codec_ul, 16);
951 descriptor->width = avio_rb32(pb);
954 descriptor->height = avio_rb32(pb);
957 descriptor->frame_layout = avio_r8(pb);
960 descriptor->aspect_ratio.num = avio_rb32(pb);
961 descriptor->aspect_ratio.den = avio_rb32(pb);
964 descriptor->field_dominance = avio_r8(pb);
967 descriptor->component_depth = avio_rb32(pb);
970 descriptor->horiz_subsampling = avio_rb32(pb);
973 descriptor->vert_subsampling = avio_rb32(pb);
976 descriptor->sample_rate.num = avio_rb32(pb);
977 descriptor->sample_rate.den = avio_rb32(pb);
979 case 0x3D06: /* SoundEssenceCompression */
980 avio_read(pb, descriptor->essence_codec_ul, 16);
983 descriptor->channels = avio_rb32(pb);
986 descriptor->bits_per_sample = avio_rb32(pb);
989 mxf_read_pixel_layout(pb, descriptor);
992 /* Private uid used by SONY C0023S01.mxf */
993 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
994 if (descriptor->extradata)
995 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
996 av_free(descriptor->extradata);
997 descriptor->extradata_size = 0;
998 descriptor->extradata = av_malloc(size);
999 if (!descriptor->extradata)
1000 return AVERROR(ENOMEM);
1001 descriptor->extradata_size = size;
1002 avio_read(pb, descriptor->extradata, size);
1004 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1005 uint32_t rsiz = avio_rb16(pb);
1006 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1007 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1008 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1016 * Match an uid independently of the version byte and up to len common bytes
1019 static int mxf_match_uid(const UID key, const UID uid, int len)
1022 for (i = 0; i < len; i++) {
1023 if (i != 7 && key[i] != uid[i])
1029 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1031 while (uls->uid[0]) {
1032 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1039 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1045 for (i = 0; i < mxf->metadata_sets_count; i++) {
1046 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1047 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1048 return mxf->metadata_sets[i];
1054 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1055 // video essence container uls
1056 { { 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 */
1057 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1058 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
1059 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1060 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1063 /* EC ULs for intra-only formats */
1064 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1065 { { 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 */
1066 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1069 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1070 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1071 { { 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 */
1072 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
1073 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1076 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1077 // sound essence container uls
1078 { { 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 */
1079 { { 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 */
1080 { { 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 */
1081 { { 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 */
1082 { { 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) */
1083 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1086 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1087 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1088 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1091 static const char* const mxf_data_essence_descriptor[] = {
1092 "vbi_vanc_smpte_436M",
1095 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1097 int i, j, nb_segments = 0;
1098 MXFIndexTableSegment **unsorted_segments;
1099 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1101 /* count number of segments, allocate arrays and copy unsorted segments */
1102 for (i = 0; i < mxf->metadata_sets_count; i++)
1103 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1107 return AVERROR_INVALIDDATA;
1109 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1110 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1111 av_freep(sorted_segments);
1112 av_free(unsorted_segments);
1113 return AVERROR(ENOMEM);
1116 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1117 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1118 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1120 *nb_sorted_segments = 0;
1122 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1123 for (i = 0; i < nb_segments; i++) {
1124 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1125 uint64_t best_index_duration = 0;
1127 for (j = 0; j < nb_segments; j++) {
1128 MXFIndexTableSegment *s = unsorted_segments[j];
1130 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1131 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1132 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1134 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1135 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1136 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1138 best_body_sid = s->body_sid;
1139 best_index_sid = s->index_sid;
1140 best_index_start = s->index_start_position;
1141 best_index_duration = s->index_duration;
1145 /* no suitable entry found -> we're done */
1149 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1150 last_body_sid = best_body_sid;
1151 last_index_sid = best_index_sid;
1152 last_index_start = best_index_start;
1155 av_free(unsorted_segments);
1161 * Computes the absolute file offset of the given essence container offset
1163 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1166 int64_t offset_in = offset; /* for logging */
1168 for (x = 0; x < mxf->partitions_count; x++) {
1169 MXFPartition *p = &mxf->partitions[x];
1171 if (p->body_sid != body_sid)
1174 if (offset < p->essence_length || !p->essence_length) {
1175 *offset_out = p->essence_offset + offset;
1179 offset -= p->essence_length;
1182 av_log(mxf->fc, AV_LOG_ERROR,
1183 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1184 offset_in, body_sid);
1186 return AVERROR_INVALIDDATA;
1190 * Returns the end position of the essence container with given BodySID, or zero if unknown
1192 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1197 for (x = 0; x < mxf->partitions_count; x++) {
1198 MXFPartition *p = &mxf->partitions[x];
1200 if (p->body_sid != body_sid)
1203 if (!p->essence_length)
1206 ret = p->essence_offset + p->essence_length;
1212 /* EditUnit -> absolute offset */
1213 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)
1216 int64_t offset_temp = 0;
1218 for (i = 0; i < index_table->nb_segments; i++) {
1219 MXFIndexTableSegment *s = index_table->segments[i];
1221 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1223 if (edit_unit < s->index_start_position + s->index_duration) {
1224 int64_t index = edit_unit - s->index_start_position;
1226 if (s->edit_unit_byte_count)
1227 offset_temp += s->edit_unit_byte_count * index;
1228 else if (s->nb_index_entries) {
1229 if (s->nb_index_entries == 2 * s->index_duration + 1)
1230 index *= 2; /* Avid index */
1232 if (index < 0 || index >= s->nb_index_entries) {
1233 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1234 index_table->index_sid, s->index_start_position);
1235 return AVERROR_INVALIDDATA;
1238 offset_temp = s->stream_offset_entries[index];
1240 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1241 index_table->index_sid, s->index_start_position);
1242 return AVERROR_INVALIDDATA;
1246 *edit_unit_out = edit_unit;
1248 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1250 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1251 offset_temp += s->edit_unit_byte_count * s->index_duration;
1256 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);
1258 return AVERROR_INVALIDDATA;
1261 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1264 int8_t max_temporal_offset = -128;
1266 /* first compute how many entries we have */
1267 for (i = 0; i < index_table->nb_segments; i++) {
1268 MXFIndexTableSegment *s = index_table->segments[i];
1270 if (!s->nb_index_entries) {
1271 index_table->nb_ptses = 0;
1272 return 0; /* no TemporalOffsets */
1275 index_table->nb_ptses += s->index_duration;
1278 /* paranoid check */
1279 if (index_table->nb_ptses <= 0)
1282 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1283 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1284 av_freep(&index_table->ptses);
1285 return AVERROR(ENOMEM);
1288 /* we may have a few bad TemporalOffsets
1289 * make sure the corresponding PTSes don't have the bogus value 0 */
1290 for (x = 0; x < index_table->nb_ptses; x++)
1291 index_table->ptses[x] = AV_NOPTS_VALUE;
1305 * We want to transform it into this:
1316 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1317 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1318 * The latter makes DTS <= PTS.
1320 for (i = x = 0; i < index_table->nb_segments; i++) {
1321 MXFIndexTableSegment *s = index_table->segments[i];
1322 int index_delta = 1;
1323 int n = s->nb_index_entries;
1325 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1326 index_delta = 2; /* Avid index */
1327 /* ignore the last entry - it's the size of the essence container */
1331 for (j = 0; j < n; j += index_delta, x++) {
1332 int offset = s->temporal_offset_entries[j] / index_delta;
1333 int index = x + offset;
1335 if (x >= index_table->nb_ptses) {
1336 av_log(mxf->fc, AV_LOG_ERROR,
1337 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1338 s->nb_index_entries, s->index_duration);
1342 index_table->fake_index[x].timestamp = x;
1343 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1345 if (index < 0 || index >= index_table->nb_ptses) {
1346 av_log(mxf->fc, AV_LOG_ERROR,
1347 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1352 index_table->ptses[index] = x;
1353 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1357 index_table->first_dts = -max_temporal_offset;
1363 * Sorts and collects index table segments into index tables.
1364 * Also computes PTSes if possible.
1366 static int mxf_compute_index_tables(MXFContext *mxf)
1368 int i, j, k, ret, nb_sorted_segments;
1369 MXFIndexTableSegment **sorted_segments = NULL;
1371 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1372 nb_sorted_segments <= 0) {
1373 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1377 /* sanity check and count unique BodySIDs/IndexSIDs */
1378 for (i = 0; i < nb_sorted_segments; i++) {
1379 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1380 mxf->nb_index_tables++;
1381 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1382 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1383 ret = AVERROR_INVALIDDATA;
1384 goto finish_decoding_index;
1388 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1389 sizeof(*mxf->index_tables));
1390 if (!mxf->index_tables) {
1391 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1392 ret = AVERROR(ENOMEM);
1393 goto finish_decoding_index;
1396 /* distribute sorted segments to index tables */
1397 for (i = j = 0; i < nb_sorted_segments; i++) {
1398 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1403 mxf->index_tables[j].nb_segments++;
1406 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1407 MXFIndexTable *t = &mxf->index_tables[j];
1409 t->segments = av_mallocz_array(t->nb_segments,
1410 sizeof(*t->segments));
1413 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1414 " pointer array\n");
1415 ret = AVERROR(ENOMEM);
1416 goto finish_decoding_index;
1419 if (sorted_segments[i]->index_start_position)
1420 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1421 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1423 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1424 t->index_sid = sorted_segments[i]->index_sid;
1425 t->body_sid = sorted_segments[i]->body_sid;
1427 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1428 goto finish_decoding_index;
1430 /* fix zero IndexDurations */
1431 for (k = 0; k < t->nb_segments; k++) {
1432 if (t->segments[k]->index_duration)
1435 if (t->nb_segments > 1)
1436 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1439 if (mxf->fc->nb_streams <= 0) {
1440 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1444 /* assume the first stream's duration is reasonable
1445 * leave index_duration = 0 on further segments in case we have any (unlikely)
1447 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1453 finish_decoding_index:
1454 av_free(sorted_segments);
1458 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1460 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1461 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1462 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1463 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1466 static int mxf_uid_to_str(UID uid, char **str)
1470 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1472 return AVERROR(ENOMEM);
1473 for (i = 0; i < sizeof(UID); i++) {
1474 snprintf(p, 2 + 1, "%.2x", uid[i]);
1476 if (i == 3 || i == 5 || i == 7 || i == 9) {
1477 snprintf(p, 1 + 1, "-");
1484 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1488 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1490 return AVERROR(ENOMEM);
1491 snprintf(p, 2 + 1, "0x");
1493 for (i = 0; i < sizeof(UID); i++) {
1494 snprintf(p, 2 + 1, "%.2X", ul[i]);
1498 for (i = 0; i < sizeof(UID); i++) {
1499 snprintf(p, 2 + 1, "%.2X", uid[i]);
1505 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1511 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1513 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1517 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1519 char buf[AV_TIMECODE_STR_SIZE];
1520 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1525 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1527 MXFStructuralComponent *component = NULL;
1528 MXFPulldownComponent *pulldown = NULL;
1530 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1534 switch (component->type) {
1535 case TimecodeComponent:
1536 return (MXFTimecodeComponent*)component;
1537 case PulldownComponent: /* timcode component may be located on a pulldown component */
1538 pulldown = (MXFPulldownComponent*)component;
1539 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1546 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_uid)
1548 MXFPackage *package = NULL;
1551 for (i = 0; i < mxf->packages_count; i++) {
1552 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1556 if (!memcmp(package->package_uid, package_uid, 16))
1562 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1564 MXFDescriptor *sub_descriptor = NULL;
1570 if (descriptor->type == MultipleDescriptor) {
1571 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1572 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1574 if (!sub_descriptor) {
1575 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1578 if (sub_descriptor->linked_track_id == track_id) {
1579 return sub_descriptor;
1582 } else if (descriptor->type == Descriptor)
1588 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1590 MXFStructuralComponent *component = NULL;
1591 MXFPackage *package = NULL;
1592 MXFDescriptor *descriptor = NULL;
1595 if (!essence_group || !essence_group->structural_components_count)
1598 /* essence groups contains multiple representations of the same media,
1599 this return the first components with a valid Descriptor typically index 0 */
1600 for (i =0; i < essence_group->structural_components_count; i++){
1601 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1605 if (!(package = mxf_resolve_source_package(mxf, component->source_package_uid)))
1608 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1615 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1617 MXFStructuralComponent *component = NULL;
1619 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1622 switch (component->type) {
1626 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1633 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1635 MXFPackage *physical_package = NULL;
1636 MXFTrack *physical_track = NULL;
1637 MXFStructuralComponent *sourceclip = NULL;
1638 MXFTimecodeComponent *mxf_tc = NULL;
1642 int64_t start_position;
1644 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1645 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1649 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_uid)))
1652 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1654 /* the name of physical source package is name of the reel or tape */
1655 if (physical_package->name && physical_package->name[0])
1656 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1658 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1659 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1661 for (j = 0; j < physical_package->tracks_count; j++) {
1662 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1663 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1667 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1668 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1672 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1673 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1676 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1677 /* scale sourceclip start_position to match physical track edit rate */
1678 start_position = av_rescale_q(sourceclip->start_position,
1679 physical_track->edit_rate,
1680 source_track->edit_rate);
1682 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1683 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1693 static int mxf_parse_structural_metadata(MXFContext *mxf)
1695 MXFPackage *material_package = NULL;
1698 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1699 /* TODO: handle multiple material packages (OP3x) */
1700 for (i = 0; i < mxf->packages_count; i++) {
1701 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1702 if (material_package) break;
1704 if (!material_package) {
1705 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1706 return AVERROR_INVALIDDATA;
1709 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1710 if (material_package->name && material_package->name[0])
1711 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1713 for (i = 0; i < material_package->tracks_count; i++) {
1714 MXFPackage *source_package = NULL;
1715 MXFTrack *material_track = NULL;
1716 MXFTrack *source_track = NULL;
1717 MXFTrack *temp_track = NULL;
1718 MXFDescriptor *descriptor = NULL;
1719 MXFStructuralComponent *component = NULL;
1720 MXFTimecodeComponent *mxf_tc = NULL;
1721 UID *essence_container_ul = NULL;
1722 const MXFCodecUL *codec_ul = NULL;
1723 const MXFCodecUL *container_ul = NULL;
1724 const MXFCodecUL *pix_fmt_ul = NULL;
1729 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1730 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1734 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1735 mxf_tc = (MXFTimecodeComponent*)component;
1736 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1737 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1738 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1742 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1743 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1747 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1748 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1752 mxf_tc = (MXFTimecodeComponent*)component;
1753 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1754 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1755 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1760 /* TODO: handle multiple source clips */
1761 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1762 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1766 source_package = mxf_resolve_source_package(mxf, component->source_package_uid);
1767 if (!source_package) {
1768 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1771 for (k = 0; k < source_package->tracks_count; k++) {
1772 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1773 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1774 ret = AVERROR_INVALIDDATA;
1777 if (temp_track->track_id == component->source_track_id) {
1778 source_track = temp_track;
1782 if (!source_track) {
1783 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1787 if (!source_track || !component)
1790 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1791 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1792 ret = AVERROR_INVALIDDATA;
1796 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1797 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1798 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1799 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1803 st = avformat_new_stream(mxf->fc, NULL);
1805 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1806 ret = AVERROR(ENOMEM);
1809 st->id = source_track->track_id;
1810 st->priv_data = source_track;
1812 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1813 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
1815 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
1816 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
1817 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
1818 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
1820 source_track->original_duration = st->duration = component->duration;
1822 if (st->duration == -1)
1823 st->duration = AV_NOPTS_VALUE;
1824 st->start_time = component->start_position;
1825 if (material_track->edit_rate.num <= 0 ||
1826 material_track->edit_rate.den <= 0) {
1827 av_log(mxf->fc, AV_LOG_WARNING,
1828 "Invalid edit rate (%d/%d) found on stream #%d, "
1829 "defaulting to 25/1\n",
1830 material_track->edit_rate.num,
1831 material_track->edit_rate.den, st->index);
1832 material_track->edit_rate = (AVRational){25, 1};
1834 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1836 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1837 * the former is accessible via st->priv_data */
1838 source_track->edit_rate = material_track->edit_rate;
1840 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1841 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1842 st->codec->codec_type = codec_ul->id;
1845 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1848 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1849 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1850 essence_container_ul = &descriptor->essence_container_ul;
1851 /* HACK: replacing the original key with mxf_encrypted_essence_container
1852 * is not allowed according to s429-6, try to find correct information anyway */
1853 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1854 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1855 for (k = 0; k < mxf->metadata_sets_count; k++) {
1856 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1857 if (metadata->type == CryptoContext) {
1858 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1864 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1865 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1866 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1867 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1868 avcodec_get_name(st->codec->codec_id));
1869 for (k = 0; k < 16; k++) {
1870 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1871 descriptor->essence_codec_ul[k]);
1872 if (!(k+1 & 19) || k == 5)
1873 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1875 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1877 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
1878 if (source_package->name && source_package->name[0])
1879 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
1881 mxf_parse_physical_source_package(mxf, source_track, st);
1883 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1884 source_track->intra_only = mxf_is_intra_only(descriptor);
1885 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1886 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1887 st->codec->codec_id = container_ul->id;
1888 st->codec->width = descriptor->width;
1889 st->codec->height = descriptor->height; /* Field height, not frame height */
1890 switch (descriptor->frame_layout) {
1891 case SegmentedFrame:
1892 /* This one is a weird layout I don't fully understand. */
1893 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1896 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1899 /* Every other line is stored and needs to be duplicated. */
1900 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1901 break; /* The correct thing to do here is fall through, but by breaking we might be
1902 able to decode some streams at half the vertical resolution, rather than not al all.
1903 It's also for compatibility with the old behavior. */
1906 case SeparateFields:
1907 switch (descriptor->field_dominance) {
1909 st->codec->field_order = AV_FIELD_TT;
1912 st->codec->field_order = AV_FIELD_BB;
1915 avpriv_request_sample(mxf->fc,
1916 "Field dominance %d support",
1917 descriptor->field_dominance);
1918 case 0: // we already have many samples with field_dominance == unknown
1921 /* Turn field height into frame height. */
1922 st->codec->height *= 2;
1925 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1927 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1928 st->codec->pix_fmt = descriptor->pix_fmt;
1929 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1930 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1931 &descriptor->essence_codec_ul);
1932 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1933 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1934 /* support files created before RP224v10 by defaulting to UYVY422
1935 if subsampling is 4:2:2 and component depth is 8-bit */
1936 if (descriptor->horiz_subsampling == 2 &&
1937 descriptor->vert_subsampling == 1 &&
1938 descriptor->component_depth == 8) {
1939 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1944 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1945 if (material_track->sequence->origin) {
1946 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1948 if (source_track->sequence->origin) {
1949 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1951 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
1952 st->display_aspect_ratio = descriptor->aspect_ratio;
1953 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1954 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1955 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1956 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))
1957 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1958 st->codec->channels = descriptor->channels;
1959 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1961 if (descriptor->sample_rate.den > 0) {
1962 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1963 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1965 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1966 "found for stream #%d, time base forced to 1/48000\n",
1967 descriptor->sample_rate.num, descriptor->sample_rate.den,
1969 avpriv_set_pts_info(st, 64, 1, 48000);
1972 /* if duration is set, rescale it from EditRate to SampleRate */
1973 if (st->duration != AV_NOPTS_VALUE)
1974 st->duration = av_rescale_q(st->duration,
1975 av_inv_q(material_track->edit_rate),
1978 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1979 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1980 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1981 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1982 else if (descriptor->bits_per_sample == 32)
1983 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1984 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1985 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1986 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1987 else if (descriptor->bits_per_sample == 32)
1988 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1989 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1990 st->need_parsing = AVSTREAM_PARSE_FULL;
1992 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1993 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1994 essence_container_ul)->id;
1995 if (codec_id >= 0 &&
1996 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1997 av_dict_set(&st->metadata, "data_type",
1998 mxf_data_essence_descriptor[codec_id], 0);
2001 if (descriptor->extradata) {
2002 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
2003 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
2005 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
2006 ret = ff_generate_avci_extradata(st);
2010 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2011 /* TODO: decode timestamps */
2012 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2021 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
2023 struct tm time = { 0 };
2024 time.tm_year = (timestamp >> 48) - 1900;
2025 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2026 time.tm_mday = (timestamp >> 32 & 0xFF);
2027 time.tm_hour = (timestamp >> 24 & 0xFF);
2028 time.tm_min = (timestamp >> 16 & 0xFF);
2029 time.tm_sec = (timestamp >> 8 & 0xFF);
2031 /* msvcrt versions of strftime calls the invalid parameter handler
2032 * (aborting the process if one isn't set) if the parameters are out
2034 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2035 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2036 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2037 time.tm_min = av_clip(time.tm_min, 0, 59);
2038 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2040 *str = av_mallocz(32);
2042 return AVERROR(ENOMEM);
2043 if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time))
2049 #define SET_STR_METADATA(pb, name, str) do { \
2050 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
2052 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2055 #define SET_UID_METADATA(pb, name, var, str) do { \
2056 avio_read(pb, var, 16); \
2057 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2059 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2062 #define SET_TS_METADATA(pb, name, var, str) do { \
2063 var = avio_rb64(pb); \
2064 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
2066 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2069 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2071 MXFContext *mxf = arg;
2072 AVFormatContext *s = mxf->fc;
2079 SET_STR_METADATA(pb, "company_name", str);
2082 SET_STR_METADATA(pb, "product_name", str);
2085 SET_STR_METADATA(pb, "product_version", str);
2088 SET_UID_METADATA(pb, "product_uid", uid, str);
2091 SET_TS_METADATA(pb, "modification_date", ts, str);
2094 SET_STR_METADATA(pb, "application_platform", str);
2097 SET_UID_METADATA(pb, "generation_uid", uid, str);
2100 SET_UID_METADATA(pb, "uid", uid, str);
2106 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2108 MXFContext *mxf = arg;
2109 AVFormatContext *s = mxf->fc;
2113 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2114 SET_STR_METADATA(pb, "project_name", str);
2119 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2120 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2121 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2122 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2123 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2124 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2125 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2126 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2127 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2128 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2129 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2130 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2131 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2132 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2133 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2134 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2135 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2136 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2137 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2138 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2139 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2140 { { 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 */
2141 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2142 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2143 { { 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 */
2144 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2145 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2146 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2147 { { 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 */
2148 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2149 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2150 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2151 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2152 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2153 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2154 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2155 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2158 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2161 case MultipleDescriptor:
2163 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2164 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2172 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2174 AVIOContext *pb = mxf->fc->pb;
2175 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2176 uint64_t klv_end = avio_tell(pb) + klv->length;
2179 return AVERROR(ENOMEM);
2180 mxf_metadataset_init(ctx, type);
2181 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2183 int tag = avio_rb16(pb);
2184 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2185 uint64_t next = avio_tell(pb) + size;
2188 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
2189 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2190 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2193 if (tag > 0x7FFF) { /* dynamic tag */
2195 for (i = 0; i < mxf->local_tags_count; i++) {
2196 int local_tag = AV_RB16(mxf->local_tags+i*18);
2197 if (local_tag == tag) {
2198 memcpy(uid, mxf->local_tags+i*18+2, 16);
2199 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
2200 PRINT_KEY(mxf->fc, "uid", uid);
2204 if (ctx_size && tag == 0x3C0A) {
2205 avio_read(pb, ctx->uid, 16);
2206 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2207 mxf_free_metadataset(&ctx, !!ctx_size);
2211 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2212 * it extending past the end of the KLV though (zzuf5.mxf). */
2213 if (avio_tell(pb) > klv_end) {
2216 mxf_free_metadataset(&ctx, !!ctx_size);
2219 av_log(mxf->fc, AV_LOG_ERROR,
2220 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2222 return AVERROR_INVALIDDATA;
2223 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2224 avio_seek(pb, next, SEEK_SET);
2226 if (ctx_size) ctx->type = type;
2227 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2231 * Matches any partition pack key, in other words:
2235 * @return non-zero if the key is a partition pack key, zero otherwise
2237 static int mxf_is_partition_pack_key(UID key)
2239 //NOTE: this is a little lax since it doesn't constraint key[14]
2240 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2241 key[13] >= 2 && key[13] <= 4;
2245 * Parses a metadata KLV
2246 * @return <0 on error, 0 otherwise
2248 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2249 int ctx_size, enum MXFMetadataSetType type)
2251 AVFormatContext *s = mxf->fc;
2253 if (klv.key[5] == 0x53) {
2254 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2256 uint64_t next = avio_tell(s->pb) + klv.length;
2257 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2259 /* only seek forward, else this can loop for a long time */
2260 if (avio_tell(s->pb) > next) {
2261 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2263 return AVERROR_INVALIDDATA;
2266 avio_seek(s->pb, next, SEEK_SET);
2269 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2276 * Seeks to the previous partition and parses it, if possible
2277 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2279 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2281 AVIOContext *pb = mxf->fc->pb;
2283 int64_t current_partition_ofs;
2286 if (!mxf->current_partition ||
2287 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2288 return 0; /* we've parsed all partitions */
2290 /* seek to previous partition */
2291 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2292 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2293 mxf->current_partition = NULL;
2295 av_dlog(mxf->fc, "seeking to previous partition\n");
2297 /* Make sure this is actually a PartitionPack, and if so parse it.
2300 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2301 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2305 if (!mxf_is_partition_pack_key(klv.key)) {
2306 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2307 return AVERROR_INVALIDDATA;
2310 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2311 * can point to just before the current partition, causing klv_read_packet()
2312 * to sync back up to it. See deadlock3.mxf
2314 if (klv.offset >= current_partition_ofs) {
2315 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2316 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2317 return AVERROR_INVALIDDATA;
2320 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2327 * Called when essence is encountered
2328 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2330 static int mxf_parse_handle_essence(MXFContext *mxf)
2332 AVIOContext *pb = mxf->fc->pb;
2335 if (mxf->parsing_backward) {
2336 return mxf_seek_to_previous_partition(mxf);
2338 if (!mxf->footer_partition) {
2339 av_dlog(mxf->fc, "no FooterPartition\n");
2343 av_dlog(mxf->fc, "seeking to FooterPartition\n");
2345 /* remember where we were so we don't end up seeking further back than this */
2346 mxf->last_forward_tell = avio_tell(pb);
2348 if (!pb->seekable) {
2349 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2353 /* seek to FooterPartition and parse backward */
2354 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2355 av_log(mxf->fc, AV_LOG_ERROR,
2356 "failed to seek to FooterPartition @ 0x%" PRIx64
2357 " (%"PRId64") - partial file?\n",
2358 mxf->run_in + mxf->footer_partition, ret);
2362 mxf->current_partition = NULL;
2363 mxf->parsing_backward = 1;
2370 * Called when the next partition or EOF is encountered
2371 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2373 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2375 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2379 * Figures out the proper offset and length of the essence container in each partition
2381 static void mxf_compute_essence_containers(MXFContext *mxf)
2385 /* everything is already correct */
2386 if (mxf->op == OPAtom)
2389 for (x = 0; x < mxf->partitions_count; x++) {
2390 MXFPartition *p = &mxf->partitions[x];
2393 continue; /* BodySID == 0 -> no essence */
2395 if (x >= mxf->partitions_count - 1)
2396 break; /* FooterPartition - can't compute length (and we don't need to) */
2398 /* essence container spans to the next partition */
2399 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2401 if (p->essence_length < 0) {
2402 /* next ThisPartition < essence_offset */
2403 p->essence_length = 0;
2404 av_log(mxf->fc, AV_LOG_ERROR,
2405 "partition %i: bad ThisPartition = %"PRIX64"\n",
2406 x+1, mxf->partitions[x+1].this_partition);
2411 static int64_t round_to_kag(int64_t position, int kag_size)
2413 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2414 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2415 int64_t ret = (position / kag_size) * kag_size;
2416 return ret == position ? ret : ret + kag_size;
2419 static int is_pcm(enum AVCodecID codec_id)
2421 /* we only care about "normal" PCM codecs until we get samples */
2422 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2426 * Deal with the case where for some audio atoms EditUnitByteCount is
2427 * very small (2, 4..). In those cases we should read more than one
2428 * sample per call to mxf_read_packet().
2430 static void mxf_handle_small_eubc(AVFormatContext *s)
2432 MXFContext *mxf = s->priv_data;
2434 /* assuming non-OPAtom == frame wrapped
2435 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2436 if (mxf->op != OPAtom)
2439 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2440 if (s->nb_streams != 1 ||
2441 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2442 !is_pcm(s->streams[0]->codec->codec_id) ||
2443 mxf->nb_index_tables != 1 ||
2444 mxf->index_tables[0].nb_segments != 1 ||
2445 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2448 /* arbitrarily default to 48 kHz PAL audio frame size */
2449 /* TODO: We could compute this from the ratio between the audio
2450 * and video edit rates for 48 kHz NTSC we could use the
2451 * 1802-1802-1802-1802-1801 pattern. */
2452 mxf->edit_units_per_packet = 1920;
2456 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2458 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2460 AVFormatContext *s = mxf->fc;
2461 AVStream *st = NULL;
2462 MXFIndexTableSegment *segment = NULL;
2463 MXFPartition *p = NULL;
2464 int essence_partition_count = 0;
2467 if (mxf->op != OPAtom)
2470 /* TODO: support raw video without a index if they exist */
2471 if (s->nb_streams != 1 || s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(s->streams[0]->codec->codec_id))
2474 /* check if file already has a IndexTableSegment */
2475 for (i = 0; i < mxf->metadata_sets_count; i++) {
2476 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2480 /* find the essence partition */
2481 for (i = 0; i < mxf->partitions_count; i++) {
2482 /* BodySID == 0 -> no essence */
2483 if (!mxf->partitions[i].body_sid)
2486 p = &mxf->partitions[i];
2487 essence_partition_count++;
2490 /* only handle files with a single essence partition */
2491 if (essence_partition_count != 1)
2494 if (!(segment = av_mallocz(sizeof(*segment))))
2495 return AVERROR(ENOMEM);
2497 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2498 mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2503 segment->type = IndexTableSegment;
2504 /* stream will be treated as small EditUnitByteCount */
2505 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codec->codec_id) * st->codec->channels) >> 3;
2506 segment->index_start_position = 0;
2507 segment->index_duration = s->streams[0]->duration;
2508 segment->index_sid = p->index_sid;
2509 segment->body_sid = p->body_sid;
2513 static void mxf_read_random_index_pack(AVFormatContext *s)
2515 MXFContext *mxf = s->priv_data;
2517 int64_t file_size, max_rip_length, min_rip_length;
2520 if (!s->pb->seekable)
2523 file_size = avio_size(s->pb);
2525 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2526 * The limit below assumes a file with nothing but partition packs and a RIP.
2527 * Before changing this, consider that a muxer may place each sample in its own partition.
2529 * 105 is the size of the smallest possible PartitionPack
2530 * 12 is the size of each RIP entry
2531 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2533 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2534 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2536 /* We're only interested in RIPs with at least two entries.. */
2537 min_rip_length = 16+1+24+4;
2539 /* See S377m section 11 */
2540 avio_seek(s->pb, file_size - 4, SEEK_SET);
2541 length = avio_rb32(s->pb);
2543 if (length < min_rip_length || length > max_rip_length)
2545 avio_seek(s->pb, file_size - length, SEEK_SET);
2546 if (klv_read_packet(&klv, s->pb) < 0 ||
2547 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2548 klv.length != length - 20)
2551 avio_skip(s->pb, klv.length - 12);
2552 mxf->footer_partition = avio_rb64(s->pb);
2555 if (mxf->run_in + mxf->footer_partition >= file_size) {
2556 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2557 mxf->footer_partition = 0;
2561 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2564 static int mxf_read_header(AVFormatContext *s)
2566 MXFContext *mxf = s->priv_data;
2568 int64_t essence_offset = 0;
2571 mxf->last_forward_tell = INT64_MAX;
2572 mxf->edit_units_per_packet = 1;
2574 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2575 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2576 return AVERROR_INVALIDDATA;
2578 avio_seek(s->pb, -14, SEEK_CUR);
2580 mxf->run_in = avio_tell(s->pb);
2582 mxf_read_random_index_pack(s);
2584 while (!avio_feof(s->pb)) {
2585 const MXFMetadataReadTableEntry *metadata;
2587 if (klv_read_packet(&klv, s->pb) < 0) {
2588 /* EOF - seek to previous partition or stop */
2589 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2595 PRINT_KEY(s, "read header", klv.key);
2596 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2597 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2598 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2599 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2600 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2602 if (!mxf->current_partition) {
2603 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2604 return AVERROR_INVALIDDATA;
2607 if (!mxf->current_partition->essence_offset) {
2608 /* for OP1a we compute essence_offset
2609 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2610 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2611 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2613 int64_t op1a_essence_offset =
2614 round_to_kag(mxf->current_partition->this_partition +
2615 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2616 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2617 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2619 if (mxf->op == OPAtom) {
2620 /* point essence_offset to the actual data
2621 * OPAtom has all the essence in one big KLV
2623 mxf->current_partition->essence_offset = avio_tell(s->pb);
2624 mxf->current_partition->essence_length = klv.length;
2626 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2627 mxf->current_partition->essence_offset = op1a_essence_offset;
2631 if (!essence_offset)
2632 essence_offset = klv.offset;
2634 /* seek to footer, previous partition or stop */
2635 if (mxf_parse_handle_essence(mxf) <= 0)
2638 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2639 /* next partition pack - keep going, seek to previous partition or stop */
2640 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2642 else if (mxf->parsing_backward)
2644 /* we're still parsing forward. proceed to parsing this partition pack */
2647 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2648 if (IS_KLV_KEY(klv.key, metadata->key)) {
2649 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2653 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2657 if (!metadata->read)
2658 avio_skip(s->pb, klv.length);
2660 /* FIXME avoid seek */
2661 if (!essence_offset) {
2662 av_log(s, AV_LOG_ERROR, "no essence\n");
2663 ret = AVERROR_INVALIDDATA;
2666 avio_seek(s->pb, essence_offset, SEEK_SET);
2668 mxf_compute_essence_containers(mxf);
2670 /* we need to do this before computing the index tables
2671 * to be able to fill in zero IndexDurations with st->duration */
2672 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2675 mxf_handle_missing_index_segment(mxf);
2676 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2679 if (mxf->nb_index_tables > 1) {
2680 /* TODO: look up which IndexSID to use via EssenceContainerData */
2681 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2682 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2683 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2684 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2685 ret = AVERROR_INVALIDDATA;
2689 mxf_handle_small_eubc(s);
2699 * Sets mxf->current_edit_unit based on what offset we're currently at.
2700 * @return next_ofs if OK, <0 on error
2702 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2704 int64_t last_ofs = -1, next_ofs = -1;
2705 MXFIndexTable *t = &mxf->index_tables[0];
2707 /* this is called from the OP1a demuxing logic, which means there
2708 * may be no index tables */
2709 if (mxf->nb_index_tables <= 0)
2712 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2713 while (mxf->current_edit_unit >= 0) {
2714 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2717 if (next_ofs <= last_ofs) {
2718 /* large next_ofs didn't change or current_edit_unit wrapped
2719 * around this fixes the infinite loop on zzuf3.mxf */
2720 av_log(mxf->fc, AV_LOG_ERROR,
2721 "next_ofs didn't change. not deriving packet timestamps\n");
2725 if (next_ofs > current_offset)
2728 last_ofs = next_ofs;
2729 mxf->current_edit_unit++;
2732 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2733 if (mxf->current_edit_unit < 0)
2739 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2740 uint64_t *sample_count)
2742 int i, total = 0, size = 0;
2743 AVStream *st = mxf->fc->streams[stream_index];
2744 MXFTrack *track = st->priv_data;
2745 AVRational time_base = av_inv_q(track->edit_rate);
2746 AVRational sample_rate = av_inv_q(st->time_base);
2747 const MXFSamplesPerFrame *spf = NULL;
2749 if ((sample_rate.num / sample_rate.den) == 48000)
2750 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2752 int remainder = (sample_rate.num * time_base.num) %
2753 (time_base.den * sample_rate.den);
2754 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2755 av_mul_q(sample_rate, time_base)));
2757 av_log(mxf->fc, AV_LOG_WARNING,
2758 "seeking detected on stream #%d with time base (%d/%d) and "
2759 "sample rate (%d/%d), audio pts won't be accurate.\n",
2760 stream_index, time_base.num, time_base.den,
2761 sample_rate.num, sample_rate.den);
2765 while (spf->samples_per_frame[size]) {
2766 total += spf->samples_per_frame[size];
2772 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2773 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2774 *sample_count += spf->samples_per_frame[i];
2780 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2783 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2784 int64_t bits_per_sample = codec->bits_per_coded_sample;
2786 if (!bits_per_sample)
2787 bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2789 pkt->pts = track->sample_count;
2791 if ( codec->channels <= 0
2792 || bits_per_sample <= 0
2793 || codec->channels * (int64_t)bits_per_sample < 8)
2794 return AVERROR(EINVAL);
2795 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2799 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2802 MXFContext *mxf = s->priv_data;
2805 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2806 PRINT_KEY(s, "read packet", klv.key);
2807 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2808 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2809 ret = mxf_decrypt_triplet(s, pkt, &klv);
2811 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2816 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2817 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2818 int index = mxf_get_stream_index(s, &klv);
2819 int64_t next_ofs, next_klv;
2822 AVCodecContext *codec;
2825 av_log(s, AV_LOG_ERROR,
2826 "error getting stream index %"PRIu32"\n",
2827 AV_RB32(klv.key + 12));
2831 st = s->streams[index];
2832 track = st->priv_data;
2834 if (s->streams[index]->discard == AVDISCARD_ALL)
2837 next_klv = avio_tell(s->pb) + klv.length;
2838 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2840 if (next_ofs >= 0 && next_klv > next_ofs) {
2841 /* if this check is hit then it's possible OPAtom was treated as OP1a
2842 * truncate the packet since it's probably very large (>2 GiB is common) */
2843 avpriv_request_sample(s,
2844 "OPAtom misinterpreted as OP1a?"
2845 "KLV for edit unit %i extending into "
2847 mxf->current_edit_unit);
2848 klv.length = next_ofs - avio_tell(s->pb);
2851 /* check for 8 channels AES3 element */
2852 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2853 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2856 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2860 ret = av_get_packet(s->pb, pkt, klv.length);
2864 pkt->stream_index = index;
2865 pkt->pos = klv.offset;
2869 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2870 /* mxf->current_edit_unit good - see if we have an
2871 * index table to derive timestamps from */
2872 MXFIndexTable *t = &mxf->index_tables[0];
2874 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2875 pkt->dts = mxf->current_edit_unit + t->first_dts;
2876 pkt->pts = t->ptses[mxf->current_edit_unit];
2877 } else if (track->intra_only) {
2878 /* intra-only -> PTS = EditUnit.
2879 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2880 pkt->pts = mxf->current_edit_unit;
2882 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2883 ret = mxf_set_audio_pts(mxf, codec, pkt);
2888 /* seek for truncated packets */
2889 avio_seek(s->pb, next_klv, SEEK_SET);
2894 avio_skip(s->pb, klv.length);
2896 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2899 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2901 MXFContext *mxf = s->priv_data;
2903 int64_t ret64, pos, next_pos;
2908 if (mxf->op != OPAtom)
2909 return mxf_read_packet_old(s, pkt);
2911 /* OPAtom - clip wrapped demuxing */
2912 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2914 t = &mxf->index_tables[0];
2916 if (mxf->current_edit_unit >= st->duration)
2919 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2921 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2924 /* compute size by finding the next edit unit or the end of the essence container
2925 * not pretty, but it works */
2926 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2927 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2928 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2929 return AVERROR_INVALIDDATA;
2932 if ((size = next_pos - pos) <= 0) {
2933 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2934 return AVERROR_INVALIDDATA;
2937 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2940 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2943 pkt->stream_index = 0;
2945 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2946 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2947 pkt->dts = mxf->current_edit_unit + t->first_dts;
2948 pkt->pts = t->ptses[mxf->current_edit_unit];
2949 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2950 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2955 mxf->current_edit_unit += edit_units;
2960 static int mxf_read_close(AVFormatContext *s)
2962 MXFContext *mxf = s->priv_data;
2965 av_freep(&mxf->packages_refs);
2967 for (i = 0; i < s->nb_streams; i++)
2968 s->streams[i]->priv_data = NULL;
2970 for (i = 0; i < mxf->metadata_sets_count; i++) {
2971 mxf_free_metadataset(mxf->metadata_sets + i, 1);
2973 av_freep(&mxf->partitions);
2974 av_freep(&mxf->metadata_sets);
2975 av_freep(&mxf->aesc);
2976 av_freep(&mxf->local_tags);
2978 if (mxf->index_tables) {
2979 for (i = 0; i < mxf->nb_index_tables; i++) {
2980 av_freep(&mxf->index_tables[i].segments);
2981 av_freep(&mxf->index_tables[i].ptses);
2982 av_freep(&mxf->index_tables[i].fake_index);
2985 av_freep(&mxf->index_tables);
2990 static int mxf_probe(AVProbeData *p) {
2991 const uint8_t *bufp = p->buf;
2992 const uint8_t *end = p->buf + p->buf_size;
2994 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2997 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2998 end -= sizeof(mxf_header_partition_pack_key);
3000 for (; bufp < end;) {
3001 if (!((bufp[13] - 1) & 0xF2)){
3002 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3003 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3004 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3005 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3006 return AVPROBE_SCORE_MAX;
3015 /* rudimentary byte seek */
3016 /* XXX: use MXF Index */
3017 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3019 AVStream *st = s->streams[stream_index];
3021 MXFContext* mxf = s->priv_data;
3025 MXFTrack *source_track = st->priv_data;
3027 /* if audio then truncate sample_time to EditRate */
3028 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3029 sample_time = av_rescale_q(sample_time, st->time_base,
3030 av_inv_q(source_track->edit_rate));
3032 if (mxf->nb_index_tables <= 0) {
3034 return AVERROR_INVALIDDATA;
3035 if (sample_time < 0)
3037 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3039 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3043 ff_update_cur_dts(s, st, sample_time);
3044 mxf->current_edit_unit = sample_time;
3046 t = &mxf->index_tables[0];
3048 /* clamp above zero, else ff_index_search_timestamp() returns negative
3049 * this also means we allow seeking before the start */
3050 sample_time = FFMAX(sample_time, 0);
3052 if (t->fake_index) {
3053 /* behave as if we have a proper index */
3054 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3057 /* no IndexEntryArray (one or more CBR segments)
3058 * make sure we don't seek past the end */
3059 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3062 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3065 ff_update_cur_dts(s, st, sample_time);
3066 mxf->current_edit_unit = sample_time;
3067 avio_seek(s->pb, seekpos, SEEK_SET);
3070 // Update all tracks sample count
3071 for (i = 0; i < s->nb_streams; i++) {
3072 AVStream *cur_st = s->streams[i];
3073 MXFTrack *cur_track = cur_st->priv_data;
3074 uint64_t current_sample_count = 0;
3075 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3076 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3080 cur_track->sample_count = current_sample_count;
3086 AVInputFormat ff_mxf_demuxer = {
3088 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3089 .priv_data_size = sizeof(MXFContext),
3090 .read_probe = mxf_probe,
3091 .read_header = mxf_read_header,
3092 .read_packet = mxf_read_packet,
3093 .read_close = mxf_read_close,
3094 .read_seek = mxf_read_seek,