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/parseutils.h"
54 #include "libavutil/timecode.h"
76 OPSONYOpt, /* FATE sample, violates the spec in places */
79 typedef struct MXFPartition {
82 MXFPartitionType type;
83 uint64_t previous_partition;
86 int64_t this_partition;
87 int64_t essence_offset; ///< absolute offset of essence
88 int64_t essence_length;
90 int64_t header_byte_count;
91 int64_t index_byte_count;
93 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
97 typedef struct MXFCryptoContext {
99 enum MXFMetadataSetType type;
100 UID source_container_ul;
103 typedef struct MXFStructuralComponent {
105 enum MXFMetadataSetType type;
106 UID source_package_ul;
107 UID source_package_uid;
108 UID data_definition_ul;
110 int64_t start_position;
112 } MXFStructuralComponent;
114 typedef struct MXFSequence {
116 enum MXFMetadataSetType type;
117 UID data_definition_ul;
118 UID *structural_components_refs;
119 int structural_components_count;
124 typedef struct MXFTrack {
126 enum MXFMetadataSetType type;
129 struct AVRational rate;
131 } MXFTimecodeComponent;
135 enum MXFMetadataSetType type;
136 UID input_segment_ref;
137 } MXFPulldownComponent;
141 enum MXFMetadataSetType type;
142 UID *structural_components_refs;
143 int structural_components_count;
149 enum MXFMetadataSetType type;
156 enum MXFMetadataSetType type;
157 MXFSequence *sequence; /* mandatory, and only one */
161 uint8_t track_number[4];
162 AVRational edit_rate;
164 uint64_t sample_count;
165 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
170 typedef struct MXFDescriptor {
172 enum MXFMetadataSetType type;
173 UID essence_container_ul;
174 UID essence_codec_ul;
176 AVRational sample_rate;
177 AVRational aspect_ratio;
179 int height; /* Field height, not frame height */
180 int frame_layout; /* See MXFFrameLayout enum */
181 int video_line_map[2];
182 #define MXF_FIELD_DOMINANCE_DEFAULT 0
183 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
184 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
188 int64_t duration; /* ContainerDuration optional property */
189 unsigned int component_depth;
190 unsigned int horiz_subsampling;
191 unsigned int vert_subsampling;
192 UID *sub_descriptors_refs;
193 int sub_descriptors_count;
197 enum AVPixelFormat pix_fmt;
200 typedef struct MXFIndexTableSegment {
202 enum MXFMetadataSetType type;
203 int edit_unit_byte_count;
206 AVRational index_edit_rate;
207 uint64_t index_start_position;
208 uint64_t index_duration;
209 int8_t *temporal_offset_entries;
211 uint64_t *stream_offset_entries;
212 int nb_index_entries;
213 } MXFIndexTableSegment;
215 typedef struct MXFPackage {
217 enum MXFMetadataSetType type;
222 MXFDescriptor *descriptor; /* only one */
229 typedef struct MXFEssenceContainerData {
231 enum MXFMetadataSetType type;
236 } MXFEssenceContainerData;
238 typedef struct MXFMetadataSet {
240 enum MXFMetadataSetType type;
243 /* decoded index table */
244 typedef struct MXFIndexTable {
247 int nb_ptses; /* number of PTSes or total duration of index */
248 int64_t first_dts; /* DTS = EditUnit + first_dts */
249 int64_t *ptses; /* maps EditUnit -> PTS */
251 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
252 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
253 int8_t *offsets; /* temporal offsets for display order to stored order conversion */
256 typedef struct MXFContext {
257 MXFPartition *partitions;
258 unsigned partitions_count;
262 UID *essence_container_data_refs;
263 int essence_container_data_count;
264 MXFMetadataSet **metadata_sets;
265 int metadata_sets_count;
269 int local_tags_count;
270 uint64_t footer_partition;
271 KLVPacket current_klv_data;
272 int current_klv_index;
274 MXFPartition *current_partition;
275 int parsing_backward;
276 int64_t last_forward_tell;
277 int last_forward_partition;
278 int64_t current_edit_unit;
280 MXFIndexTable *index_tables;
281 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
284 enum MXFWrappingScheme {
289 /* NOTE: klv_offset is not set (-1) for local keys */
290 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
292 typedef struct MXFMetadataReadTableEntry {
294 MXFMetadataReadFunc *read;
296 enum MXFMetadataSetType type;
297 } MXFMetadataReadTableEntry;
299 static int mxf_read_close(AVFormatContext *s);
301 /* partial keys to match */
302 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
303 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
304 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
305 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
306 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
307 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
308 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
309 /* complete keys to match */
310 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 };
311 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
312 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
313 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 };
314 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
315 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
316 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
317 static const uint8_t mxf_indirect_value_utf16le[] = { 0x4c,0x00,0x02,0x10,0x01,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
318 static const uint8_t mxf_indirect_value_utf16be[] = { 0x42,0x01,0x10,0x02,0x00,0x00,0x00,0x00,0x00,0x06,0x0e,0x2b,0x34,0x01,0x04,0x01,0x01 };
320 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
322 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
324 MXFIndexTableSegment *seg;
325 switch ((*ctx)->type) {
327 av_freep(&((MXFDescriptor *)*ctx)->extradata);
329 case MultipleDescriptor:
330 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
333 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
336 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
339 case MaterialPackage:
340 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
341 av_freep(&((MXFPackage *)*ctx)->name);
342 av_freep(&((MXFPackage *)*ctx)->comment_refs);
345 av_freep(&((MXFTaggedValue *)*ctx)->name);
346 av_freep(&((MXFTaggedValue *)*ctx)->value);
349 av_freep(&((MXFTrack *)*ctx)->name);
351 case IndexTableSegment:
352 seg = (MXFIndexTableSegment *)*ctx;
353 av_freep(&seg->temporal_offset_entries);
354 av_freep(&seg->flag_entries);
355 av_freep(&seg->stream_offset_entries);
363 static int64_t klv_decode_ber_length(AVIOContext *pb)
365 uint64_t size = avio_r8(pb);
366 if (size & 0x80) { /* long form */
367 int bytes_num = size & 0x7f;
368 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
370 return AVERROR_INVALIDDATA;
373 size = size << 8 | avio_r8(pb);
378 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
381 for (i = 0; i < size && !avio_feof(pb); i++) {
385 else if (b != key[i])
391 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
393 if (!mxf_read_sync(pb, mxf_klv_key, 4))
394 return AVERROR_INVALIDDATA;
395 klv->offset = avio_tell(pb) - 4;
396 memcpy(klv->key, mxf_klv_key, 4);
397 avio_read(pb, klv->key + 4, 12);
398 klv->length = klv_decode_ber_length(pb);
399 return klv->length == -1 ? -1 : 0;
402 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
406 for (i = 0; i < s->nb_streams; i++) {
407 MXFTrack *track = s->streams[i]->priv_data;
409 if (track && (!body_sid || !track->body_sid || track->body_sid == body_sid) && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
412 /* return 0 if only one stream, for OP Atom files with 0 as track number */
413 return s->nb_streams == 1 ? 0 : -1;
416 static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
418 // we look for partition where the offset is placed
420 int64_t this_partition;
423 b = mxf->partitions_count;
427 this_partition = mxf->partitions[m].this_partition;
428 if (this_partition <= offset)
436 return mxf->partitions[a].body_sid;
439 /* XXX: use AVBitStreamFilter */
440 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
442 const uint8_t *buf_ptr, *end_ptr;
446 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
447 return AVERROR_INVALIDDATA;
448 length = av_get_packet(pb, pkt, length);
451 data_ptr = pkt->data;
452 end_ptr = pkt->data + length;
453 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
454 for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
455 for (i = 0; i < st->codecpar->channels; i++) {
456 uint32_t sample = bytestream_get_le32(&buf_ptr);
457 if (st->codecpar->bits_per_coded_sample == 24)
458 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
460 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
462 buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
464 av_shrink_packet(pkt, data_ptr - pkt->data);
468 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
470 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
471 MXFContext *mxf = s->priv_data;
472 AVIOContext *pb = s->pb;
473 int64_t end = avio_tell(pb) + klv->length;
476 uint64_t plaintext_size;
482 if (!mxf->aesc && s->key && s->keylen == 16) {
483 mxf->aesc = av_aes_alloc();
485 return AVERROR(ENOMEM);
486 av_aes_init(mxf->aesc, s->key, 128, 1);
489 avio_skip(pb, klv_decode_ber_length(pb));
491 klv_decode_ber_length(pb);
492 plaintext_size = avio_rb64(pb);
494 klv_decode_ber_length(pb);
495 avio_read(pb, klv->key, 16);
496 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
497 return AVERROR_INVALIDDATA;
499 body_sid = find_body_sid_by_offset(mxf, klv->offset);
500 index = mxf_get_stream_index(s, klv, body_sid);
502 return AVERROR_INVALIDDATA;
504 klv_decode_ber_length(pb);
505 orig_size = avio_rb64(pb);
506 if (orig_size < plaintext_size)
507 return AVERROR_INVALIDDATA;
509 size = klv_decode_ber_length(pb);
510 if (size < 32 || size - 32 < orig_size)
511 return AVERROR_INVALIDDATA;
512 avio_read(pb, ivec, 16);
513 avio_read(pb, tmpbuf, 16);
515 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
516 if (memcmp(tmpbuf, checkv, 16))
517 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
519 size = av_get_packet(pb, pkt, size);
522 else if (size < plaintext_size)
523 return AVERROR_INVALIDDATA;
524 size -= plaintext_size;
526 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
527 &pkt->data[plaintext_size], size >> 4, ivec, 1);
528 av_shrink_packet(pkt, orig_size);
529 pkt->stream_index = index;
530 avio_skip(pb, end - avio_tell(pb));
534 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
536 MXFContext *mxf = arg;
537 int item_num = avio_rb32(pb);
538 int item_len = avio_rb32(pb);
540 if (item_len != 18) {
541 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
542 return AVERROR_PATCHWELCOME;
544 if (item_num > 65536 || item_num < 0) {
545 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
546 return AVERROR_INVALIDDATA;
549 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
550 av_free(mxf->local_tags);
551 mxf->local_tags_count = 0;
552 mxf->local_tags = av_calloc(item_num, item_len);
553 if (!mxf->local_tags)
554 return AVERROR(ENOMEM);
555 mxf->local_tags_count = item_num;
556 avio_read(pb, mxf->local_tags, item_num*item_len);
560 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
562 MXFContext *mxf = arg;
563 MXFPartition *partition, *tmp_part;
565 uint64_t footer_partition;
566 uint32_t nb_essence_containers;
568 if (mxf->partitions_count >= INT_MAX / 2)
569 return AVERROR_INVALIDDATA;
571 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
573 return AVERROR(ENOMEM);
574 mxf->partitions = tmp_part;
576 if (mxf->parsing_backward) {
577 /* insert the new partition pack in the middle
578 * this makes the entries in mxf->partitions sorted by offset */
579 memmove(&mxf->partitions[mxf->last_forward_partition+1],
580 &mxf->partitions[mxf->last_forward_partition],
581 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
582 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
584 mxf->last_forward_partition++;
585 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
588 memset(partition, 0, sizeof(*partition));
589 mxf->partitions_count++;
590 partition->pack_length = avio_tell(pb) - klv_offset + size;
591 partition->pack_ofs = klv_offset;
595 partition->type = Header;
598 partition->type = BodyPartition;
601 partition->type = Footer;
604 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
605 return AVERROR_INVALIDDATA;
608 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
609 partition->closed = partition->type == Footer || !(uid[14] & 1);
610 partition->complete = uid[14] > 2;
612 partition->kag_size = avio_rb32(pb);
613 partition->this_partition = avio_rb64(pb);
614 partition->previous_partition = avio_rb64(pb);
615 footer_partition = avio_rb64(pb);
616 partition->header_byte_count = avio_rb64(pb);
617 partition->index_byte_count = avio_rb64(pb);
618 partition->index_sid = avio_rb32(pb);
619 partition->body_offset = avio_rb64(pb);
620 partition->body_sid = avio_rb32(pb);
621 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
622 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
623 return AVERROR_INVALIDDATA;
625 nb_essence_containers = avio_rb32(pb);
627 if (partition->this_partition &&
628 partition->previous_partition == partition->this_partition) {
629 av_log(mxf->fc, AV_LOG_ERROR,
630 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
631 partition->previous_partition);
632 /* override with the actual previous partition offset */
633 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
635 mxf->partitions + mxf->last_forward_partition - 2;
636 partition->previous_partition = prev->this_partition;
638 /* if no previous body partition are found point to the header
640 if (partition->previous_partition == partition->this_partition)
641 partition->previous_partition = 0;
642 av_log(mxf->fc, AV_LOG_ERROR,
643 "Overriding PreviousPartition with %"PRIx64"\n",
644 partition->previous_partition);
647 /* some files don't have FooterPartition set in every partition */
648 if (footer_partition) {
649 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
650 av_log(mxf->fc, AV_LOG_ERROR,
651 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
652 mxf->footer_partition, footer_partition);
654 mxf->footer_partition = footer_partition;
658 av_log(mxf->fc, AV_LOG_TRACE,
659 "PartitionPack: ThisPartition = 0x%"PRIX64
660 ", PreviousPartition = 0x%"PRIX64", "
661 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
662 partition->this_partition,
663 partition->previous_partition, footer_partition,
664 partition->index_sid, partition->body_sid);
666 /* sanity check PreviousPartition if set */
667 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
668 if (partition->previous_partition &&
669 mxf->run_in + partition->previous_partition >= klv_offset) {
670 av_log(mxf->fc, AV_LOG_ERROR,
671 "PreviousPartition points to this partition or forward\n");
672 return AVERROR_INVALIDDATA;
675 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
676 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
677 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
678 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
679 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
680 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
681 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
682 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
683 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
684 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
685 else if (op[12] == 0x10) {
686 /* SMPTE 390m: "There shall be exactly one essence container"
687 * The following block deals with files that violate this, namely:
688 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
689 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
690 if (nb_essence_containers != 1) {
691 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
695 av_log(mxf->fc, AV_LOG_WARNING,
696 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
697 nb_essence_containers,
698 op == OP1a ? "OP1a" : "OPAtom");
704 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
708 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
709 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
710 partition->kag_size);
712 if (mxf->op == OPSONYOpt)
713 partition->kag_size = 512;
715 partition->kag_size = 1;
717 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
723 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
725 MXFMetadataSet **tmp;
727 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
729 return AVERROR(ENOMEM);
730 mxf->metadata_sets = tmp;
731 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
732 mxf->metadata_sets_count++;
736 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
738 MXFCryptoContext *cryptocontext = arg;
740 return AVERROR_INVALIDDATA;
741 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
742 avio_read(pb, cryptocontext->source_container_ul, 16);
746 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
748 *count = avio_rb32(pb);
749 *refs = av_calloc(*count, sizeof(UID));
752 return AVERROR(ENOMEM);
754 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
755 avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
759 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
764 if (size < 0 || size > INT_MAX/2)
765 return AVERROR(EINVAL);
767 buf_size = size + size / 2 + 1;
768 *str = av_malloc(buf_size);
770 return AVERROR(ENOMEM);
773 ret = avio_get_str16be(pb, size, *str, buf_size);
775 ret = avio_get_str16le(pb, size, *str, buf_size);
785 #define READ_STR16(type, big_endian) \
786 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
788 return mxf_read_utf16_string(pb, size, str, big_endian); \
794 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
796 MXFContext *mxf = arg;
799 if (mxf->packages_refs)
800 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
801 av_free(mxf->packages_refs);
802 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
804 av_free(mxf->essence_container_data_refs);
805 return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
810 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
812 MXFStructuralComponent *source_clip = arg;
815 source_clip->duration = avio_rb64(pb);
818 source_clip->start_position = avio_rb64(pb);
821 /* UMID, only get last 16 bytes */
822 avio_read(pb, source_clip->source_package_ul, 16);
823 avio_read(pb, source_clip->source_package_uid, 16);
826 source_clip->source_track_id = avio_rb32(pb);
832 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
834 MXFTimecodeComponent *mxf_timecode = arg;
837 mxf_timecode->start_frame = avio_rb64(pb);
840 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
843 mxf_timecode->drop_frame = avio_r8(pb);
849 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
851 MXFPulldownComponent *mxf_pulldown = arg;
854 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
860 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
862 MXFTrack *track = arg;
865 track->track_id = avio_rb32(pb);
868 avio_read(pb, track->track_number, 4);
871 mxf_read_utf16be_string(pb, size, &track->name);
874 track->edit_rate.num = avio_rb32(pb);
875 track->edit_rate.den = avio_rb32(pb);
878 avio_read(pb, track->sequence_ref, 16);
884 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
886 MXFSequence *sequence = arg;
889 sequence->duration = avio_rb64(pb);
892 avio_read(pb, sequence->data_definition_ul, 16);
895 sequence->origin = avio_r8(pb);
898 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
899 &sequence->structural_components_count);
904 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
906 MXFEssenceGroup *essence_group = arg;
909 essence_group->duration = avio_rb64(pb);
912 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
913 &essence_group->structural_components_count);
918 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
920 MXFPackage *package = arg;
923 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
924 &package->tracks_count);
927 avio_read(pb, package->package_ul, 16);
928 avio_read(pb, package->package_uid, 16);
931 avio_read(pb, package->descriptor_ref, 16);
934 return mxf_read_utf16be_string(pb, size, &package->name);
936 return mxf_read_strong_ref_array(pb, &package->comment_refs,
937 &package->comment_count);
942 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
944 MXFEssenceContainerData *essence_data = arg;
947 /* linked package umid UMID */
948 avio_read(pb, essence_data->package_ul, 16);
949 avio_read(pb, essence_data->package_uid, 16);
952 essence_data->index_sid = avio_rb32(pb);
955 essence_data->body_sid = avio_rb32(pb);
961 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
965 segment->nb_index_entries = avio_rb32(pb);
967 length = avio_rb32(pb);
968 if(segment->nb_index_entries && length < 11)
969 return AVERROR_INVALIDDATA;
971 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
972 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
973 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
974 av_freep(&segment->temporal_offset_entries);
975 av_freep(&segment->flag_entries);
976 return AVERROR(ENOMEM);
979 for (i = 0; i < segment->nb_index_entries; i++) {
981 return AVERROR_INVALIDDATA;
982 segment->temporal_offset_entries[i] = avio_r8(pb);
983 avio_r8(pb); /* KeyFrameOffset */
984 segment->flag_entries[i] = avio_r8(pb);
985 segment->stream_offset_entries[i] = avio_rb64(pb);
986 avio_skip(pb, length - 11);
991 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
993 MXFIndexTableSegment *segment = arg;
996 segment->edit_unit_byte_count = avio_rb32(pb);
997 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1000 segment->index_sid = avio_rb32(pb);
1001 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1004 segment->body_sid = avio_rb32(pb);
1005 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1008 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1009 return mxf_read_index_entry_array(pb, segment);
1011 segment->index_edit_rate.num = avio_rb32(pb);
1012 segment->index_edit_rate.den = avio_rb32(pb);
1013 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1014 segment->index_edit_rate.den);
1017 segment->index_start_position = avio_rb64(pb);
1018 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1021 segment->index_duration = avio_rb64(pb);
1022 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1028 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1030 int code, value, ofs = 0;
1031 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1035 value = avio_r8(pb);
1036 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1039 layout[ofs++] = code;
1040 layout[ofs++] = value;
1042 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1043 } while (code != 0); /* SMPTE 377M E.2.46 */
1045 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1048 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1050 MXFDescriptor *descriptor = arg;
1051 int entry_count, entry_size;
1055 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1056 &descriptor->sub_descriptors_count);
1057 case 0x3002: /* ContainerDuration */
1058 descriptor->duration = avio_rb64(pb);
1061 avio_read(pb, descriptor->essence_container_ul, 16);
1064 avio_read(pb, descriptor->codec_ul, 16);
1067 descriptor->linked_track_id = avio_rb32(pb);
1069 case 0x3201: /* PictureEssenceCoding */
1070 avio_read(pb, descriptor->essence_codec_ul, 16);
1073 descriptor->width = avio_rb32(pb);
1076 descriptor->height = avio_rb32(pb);
1079 descriptor->frame_layout = avio_r8(pb);
1082 entry_count = avio_rb32(pb);
1083 entry_size = avio_rb32(pb);
1084 if (entry_size == 4) {
1085 if (entry_count > 0)
1086 descriptor->video_line_map[0] = avio_rb32(pb);
1088 descriptor->video_line_map[0] = 0;
1089 if (entry_count > 1)
1090 descriptor->video_line_map[1] = avio_rb32(pb);
1092 descriptor->video_line_map[1] = 0;
1094 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1097 descriptor->aspect_ratio.num = avio_rb32(pb);
1098 descriptor->aspect_ratio.den = avio_rb32(pb);
1101 descriptor->field_dominance = avio_r8(pb);
1104 descriptor->component_depth = avio_rb32(pb);
1107 descriptor->horiz_subsampling = avio_rb32(pb);
1110 descriptor->vert_subsampling = avio_rb32(pb);
1113 descriptor->sample_rate.num = avio_rb32(pb);
1114 descriptor->sample_rate.den = avio_rb32(pb);
1116 case 0x3D06: /* SoundEssenceCompression */
1117 avio_read(pb, descriptor->essence_codec_ul, 16);
1120 descriptor->channels = avio_rb32(pb);
1123 descriptor->bits_per_sample = avio_rb32(pb);
1126 mxf_read_pixel_layout(pb, descriptor);
1129 /* Private uid used by SONY C0023S01.mxf */
1130 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1131 if (descriptor->extradata)
1132 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1133 av_free(descriptor->extradata);
1134 descriptor->extradata_size = 0;
1135 descriptor->extradata = av_malloc(size);
1136 if (!descriptor->extradata)
1137 return AVERROR(ENOMEM);
1138 descriptor->extradata_size = size;
1139 avio_read(pb, descriptor->extradata, size);
1141 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1142 uint32_t rsiz = avio_rb16(pb);
1143 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1144 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1145 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1152 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1154 MXFTaggedValue *tagged_value = arg;
1160 avio_read(pb, key, 17);
1161 /* TODO: handle other types of of indirect values */
1162 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1163 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1164 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1165 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1170 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1172 MXFTaggedValue *tagged_value = arg;
1175 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1177 return mxf_read_indirect_value(tagged_value, pb, size);
1183 * Match an uid independently of the version byte and up to len common bytes
1186 static int mxf_match_uid(const UID key, const UID uid, int len)
1189 for (i = 0; i < len; i++) {
1190 if (i != 7 && key[i] != uid[i])
1196 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1198 while (uls->uid[0]) {
1199 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1206 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1212 for (i = 0; i < mxf->metadata_sets_count; i++) {
1213 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1214 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1215 return mxf->metadata_sets[i];
1221 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1222 // video essence container uls
1223 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 },
1224 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264 }, /* H.264 frame wrapped */
1225 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1 }, /* VC-1 frame wrapped */
1226 { { 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 */
1227 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* Type D-10 mapping of 40Mbps 525/60-I */
1228 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1229 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* uncompressed picture */
1230 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1231 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1232 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1233 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1236 /* EC ULs for intra-only formats */
1237 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1238 { { 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 */
1239 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1242 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1243 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1244 { { 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 */
1245 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG 2000 code stream */
1246 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1249 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1250 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1251 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1252 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1253 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1254 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1255 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1258 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1259 // sound essence container uls
1260 { { 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 */
1261 { { 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 */
1262 { { 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 */
1263 { { 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 */
1264 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG-2 AAC ADTS (legacy) */
1265 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1268 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1269 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1270 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1273 static const char * const mxf_data_essence_descriptor[] = {
1274 "vbi_vanc_smpte_436M",
1277 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1279 int i, j, nb_segments = 0;
1280 MXFIndexTableSegment **unsorted_segments;
1281 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1283 /* count number of segments, allocate arrays and copy unsorted segments */
1284 for (i = 0; i < mxf->metadata_sets_count; i++)
1285 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1289 return AVERROR_INVALIDDATA;
1291 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1292 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1293 av_freep(sorted_segments);
1294 av_free(unsorted_segments);
1295 return AVERROR(ENOMEM);
1298 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1299 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1300 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1302 *nb_sorted_segments = 0;
1304 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1305 for (i = 0; i < nb_segments; i++) {
1306 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1307 uint64_t best_index_duration = 0;
1309 for (j = 0; j < nb_segments; j++) {
1310 MXFIndexTableSegment *s = unsorted_segments[j];
1312 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1313 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1314 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1317 s->body_sid > last_body_sid ||
1318 s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1319 s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1321 s->body_sid < best_body_sid ||
1322 s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1323 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1324 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position == best_index_start && s->index_duration > best_index_duration)) {
1326 best_body_sid = s->body_sid;
1327 best_index_sid = s->index_sid;
1328 best_index_start = s->index_start_position;
1329 best_index_duration = s->index_duration;
1333 /* no suitable entry found -> we're done */
1337 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1338 last_body_sid = best_body_sid;
1339 last_index_sid = best_index_sid;
1340 last_index_start = best_index_start;
1343 av_free(unsorted_segments);
1349 * Computes the absolute file offset of the given essence container offset
1351 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1353 MXFPartition *last_p = NULL;
1357 return AVERROR(EINVAL);
1360 b = mxf->partitions_count;
1363 m0 = m = (a + b) >> 1;
1365 while (m < b && mxf->partitions[m].body_sid != body_sid)
1368 if (m < b && mxf->partitions[m].body_offset <= offset)
1375 last_p = &mxf->partitions[a];
1377 if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1378 *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1382 av_log(mxf->fc, AV_LOG_ERROR,
1383 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1386 return AVERROR_INVALIDDATA;
1390 * Returns the end position of the essence container with given BodySID, or zero if unknown
1392 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1397 for (x = 0; x < mxf->partitions_count; x++) {
1398 MXFPartition *p = &mxf->partitions[x];
1400 if (p->body_sid != body_sid)
1403 if (!p->essence_length)
1406 ret = p->essence_offset + p->essence_length;
1412 /* EditUnit -> absolute offset */
1413 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)
1416 int64_t offset_temp = 0;
1418 for (i = 0; i < index_table->nb_segments; i++) {
1419 MXFIndexTableSegment *s = index_table->segments[i];
1421 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1423 if (edit_unit < s->index_start_position + s->index_duration) {
1424 int64_t index = edit_unit - s->index_start_position;
1426 if (s->edit_unit_byte_count)
1427 offset_temp += s->edit_unit_byte_count * index;
1428 else if (s->nb_index_entries) {
1429 if (s->nb_index_entries == 2 * s->index_duration + 1)
1430 index *= 2; /* Avid index */
1432 if (index < 0 || index >= s->nb_index_entries) {
1433 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1434 index_table->index_sid, s->index_start_position);
1435 return AVERROR_INVALIDDATA;
1438 offset_temp = s->stream_offset_entries[index];
1440 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1441 index_table->index_sid, s->index_start_position);
1442 return AVERROR_INVALIDDATA;
1446 *edit_unit_out = edit_unit;
1448 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1450 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1451 offset_temp += s->edit_unit_byte_count * s->index_duration;
1456 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);
1458 return AVERROR_INVALIDDATA;
1461 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1464 int8_t max_temporal_offset = -128;
1467 /* first compute how many entries we have */
1468 for (i = 0; i < index_table->nb_segments; i++) {
1469 MXFIndexTableSegment *s = index_table->segments[i];
1471 if (!s->nb_index_entries) {
1472 index_table->nb_ptses = 0;
1473 return 0; /* no TemporalOffsets */
1476 index_table->nb_ptses += s->index_duration;
1479 /* paranoid check */
1480 if (index_table->nb_ptses <= 0)
1483 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1484 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1485 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1486 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1487 av_freep(&index_table->ptses);
1488 av_freep(&index_table->fake_index);
1489 av_freep(&index_table->offsets);
1490 return AVERROR(ENOMEM);
1493 /* we may have a few bad TemporalOffsets
1494 * make sure the corresponding PTSes don't have the bogus value 0 */
1495 for (x = 0; x < index_table->nb_ptses; x++)
1496 index_table->ptses[x] = AV_NOPTS_VALUE;
1510 * We want to transform it into this:
1521 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1522 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1523 * The latter makes DTS <= PTS.
1525 for (i = x = 0; i < index_table->nb_segments; i++) {
1526 MXFIndexTableSegment *s = index_table->segments[i];
1527 int index_delta = 1;
1528 int n = s->nb_index_entries;
1530 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1531 index_delta = 2; /* Avid index */
1532 /* ignore the last entry - it's the size of the essence container */
1536 for (j = 0; j < n; j += index_delta, x++) {
1537 int offset = s->temporal_offset_entries[j] / index_delta;
1538 int index = x + offset;
1540 if (x >= index_table->nb_ptses) {
1541 av_log(mxf->fc, AV_LOG_ERROR,
1542 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1543 s->nb_index_entries, s->index_duration);
1547 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1549 if (index < 0 || index >= index_table->nb_ptses) {
1550 av_log(mxf->fc, AV_LOG_ERROR,
1551 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1556 index_table->offsets[x] = offset;
1557 index_table->ptses[index] = x;
1558 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1562 /* calculate the fake index table in display order */
1563 for (x = 0; x < index_table->nb_ptses; x++) {
1564 index_table->fake_index[x].timestamp = x;
1565 if (index_table->ptses[x] != AV_NOPTS_VALUE)
1566 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1570 index_table->first_dts = -max_temporal_offset;
1576 * Sorts and collects index table segments into index tables.
1577 * Also computes PTSes if possible.
1579 static int mxf_compute_index_tables(MXFContext *mxf)
1581 int i, j, k, ret, nb_sorted_segments;
1582 MXFIndexTableSegment **sorted_segments = NULL;
1584 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1585 nb_sorted_segments <= 0) {
1586 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1590 /* sanity check and count unique BodySIDs/IndexSIDs */
1591 for (i = 0; i < nb_sorted_segments; i++) {
1592 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1593 mxf->nb_index_tables++;
1594 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1595 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1596 ret = AVERROR_INVALIDDATA;
1597 goto finish_decoding_index;
1601 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1602 sizeof(*mxf->index_tables));
1603 if (!mxf->index_tables) {
1604 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1605 ret = AVERROR(ENOMEM);
1606 goto finish_decoding_index;
1609 /* distribute sorted segments to index tables */
1610 for (i = j = 0; i < nb_sorted_segments; i++) {
1611 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1616 mxf->index_tables[j].nb_segments++;
1619 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1620 MXFIndexTable *t = &mxf->index_tables[j];
1621 MXFTrack *mxf_track = NULL;
1623 t->segments = av_mallocz_array(t->nb_segments,
1624 sizeof(*t->segments));
1627 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1628 " pointer array\n");
1629 ret = AVERROR(ENOMEM);
1630 goto finish_decoding_index;
1633 if (sorted_segments[i]->index_start_position)
1634 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1635 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1637 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1638 t->index_sid = sorted_segments[i]->index_sid;
1639 t->body_sid = sorted_segments[i]->body_sid;
1641 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1642 goto finish_decoding_index;
1644 for (k = 0; k < mxf->fc->nb_streams; k++) {
1645 MXFTrack *track = mxf->fc->streams[k]->priv_data;
1646 if (track && track->index_sid == t->index_sid) {
1652 /* fix zero IndexDurations */
1653 for (k = 0; k < t->nb_segments; k++) {
1654 if (t->segments[k]->index_duration)
1657 if (t->nb_segments > 1)
1658 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1662 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1666 /* assume the first stream's duration is reasonable
1667 * leave index_duration = 0 on further segments in case we have any (unlikely)
1669 t->segments[k]->index_duration = mxf_track->original_duration;
1675 finish_decoding_index:
1676 av_free(sorted_segments);
1680 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1682 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1683 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1684 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1685 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1688 static int mxf_uid_to_str(UID uid, char **str)
1692 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1694 return AVERROR(ENOMEM);
1695 for (i = 0; i < sizeof(UID); i++) {
1696 snprintf(p, 2 + 1, "%.2x", uid[i]);
1698 if (i == 3 || i == 5 || i == 7 || i == 9) {
1699 snprintf(p, 1 + 1, "-");
1706 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1710 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1712 return AVERROR(ENOMEM);
1713 snprintf(p, 2 + 1, "0x");
1715 for (i = 0; i < sizeof(UID); i++) {
1716 snprintf(p, 2 + 1, "%.2X", ul[i]);
1720 for (i = 0; i < sizeof(UID); i++) {
1721 snprintf(p, 2 + 1, "%.2X", uid[i]);
1727 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1733 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1735 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1739 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1741 char buf[AV_TIMECODE_STR_SIZE];
1742 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1747 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1749 MXFStructuralComponent *component = NULL;
1750 MXFPulldownComponent *pulldown = NULL;
1752 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1756 switch (component->type) {
1757 case TimecodeComponent:
1758 return (MXFTimecodeComponent*)component;
1759 case PulldownComponent: /* timcode component may be located on a pulldown component */
1760 pulldown = (MXFPulldownComponent*)component;
1761 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1768 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1770 MXFPackage *package = NULL;
1773 for (i = 0; i < mxf->packages_count; i++) {
1774 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1778 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1784 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1786 MXFDescriptor *sub_descriptor = NULL;
1792 if (descriptor->type == MultipleDescriptor) {
1793 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1794 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1796 if (!sub_descriptor) {
1797 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1800 if (sub_descriptor->linked_track_id == track_id) {
1801 return sub_descriptor;
1804 } else if (descriptor->type == Descriptor)
1810 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1812 MXFStructuralComponent *component = NULL;
1813 MXFPackage *package = NULL;
1814 MXFDescriptor *descriptor = NULL;
1817 if (!essence_group || !essence_group->structural_components_count)
1820 /* essence groups contains multiple representations of the same media,
1821 this return the first components with a valid Descriptor typically index 0 */
1822 for (i =0; i < essence_group->structural_components_count; i++){
1823 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1827 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1830 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1837 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1839 MXFStructuralComponent *component = NULL;
1841 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1844 switch (component->type) {
1848 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1855 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1857 MXFTaggedValue *tag;
1861 for (i = 0; i < package->comment_count; i++) {
1862 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1863 if (!tag || !tag->name || !tag->value)
1866 size = strlen(tag->name) + 8 + 1;
1867 key = av_mallocz(size);
1869 return AVERROR(ENOMEM);
1871 snprintf(key, size, "comment_%s", tag->name);
1872 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1877 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1879 MXFPackage *physical_package = NULL;
1880 MXFTrack *physical_track = NULL;
1881 MXFStructuralComponent *sourceclip = NULL;
1882 MXFTimecodeComponent *mxf_tc = NULL;
1886 int64_t start_position;
1888 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1889 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1893 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1896 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1898 /* the name of physical source package is name of the reel or tape */
1899 if (physical_package->name && physical_package->name[0])
1900 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1902 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1903 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1905 for (j = 0; j < physical_package->tracks_count; j++) {
1906 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1907 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1911 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1912 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1916 if (physical_track->edit_rate.num <= 0 ||
1917 physical_track->edit_rate.den <= 0) {
1918 av_log(mxf->fc, AV_LOG_WARNING,
1919 "Invalid edit rate (%d/%d) found on structural"
1920 " component #%d, defaulting to 25/1\n",
1921 physical_track->edit_rate.num,
1922 physical_track->edit_rate.den, i);
1923 physical_track->edit_rate = (AVRational){25, 1};
1926 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1927 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1930 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1931 /* scale sourceclip start_position to match physical track edit rate */
1932 start_position = av_rescale_q(sourceclip->start_position,
1933 physical_track->edit_rate,
1934 source_track->edit_rate);
1936 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1937 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1947 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
1949 MXFStructuralComponent *component = NULL;
1950 const MXFCodecUL *codec_ul = NULL;
1951 MXFPackage tmp_package;
1955 for (j = 0; j < track->sequence->structural_components_count; j++) {
1956 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
1964 st = avformat_new_stream(mxf->fc, NULL);
1966 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
1967 return AVERROR(ENOMEM);
1970 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
1971 st->codecpar->codec_id = AV_CODEC_ID_NONE;
1972 st->id = track->track_id;
1974 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
1975 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
1976 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
1977 if (track->name && track->name[0])
1978 av_dict_set(&st->metadata, "track_name", track->name, 0);
1980 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
1981 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
1985 static int mxf_parse_structural_metadata(MXFContext *mxf)
1987 MXFPackage *material_package = NULL;
1990 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
1991 /* TODO: handle multiple material packages (OP3x) */
1992 for (i = 0; i < mxf->packages_count; i++) {
1993 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1994 if (material_package) break;
1996 if (!material_package) {
1997 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1998 return AVERROR_INVALIDDATA;
2001 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2002 if (material_package->name && material_package->name[0])
2003 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2004 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2006 for (i = 0; i < material_package->tracks_count; i++) {
2007 MXFPackage *source_package = NULL;
2008 MXFTrack *material_track = NULL;
2009 MXFTrack *source_track = NULL;
2010 MXFTrack *temp_track = NULL;
2011 MXFDescriptor *descriptor = NULL;
2012 MXFStructuralComponent *component = NULL;
2013 MXFTimecodeComponent *mxf_tc = NULL;
2014 UID *essence_container_ul = NULL;
2015 const MXFCodecUL *codec_ul = NULL;
2016 const MXFCodecUL *container_ul = NULL;
2017 const MXFCodecUL *pix_fmt_ul = NULL;
2022 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2023 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2027 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2028 mxf_tc = (MXFTimecodeComponent*)component;
2029 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2030 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2031 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2035 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2036 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2040 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2041 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2045 mxf_tc = (MXFTimecodeComponent*)component;
2046 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2047 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2048 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2053 /* TODO: handle multiple source clips, only finds first valid source clip */
2054 if(material_track->sequence->structural_components_count > 1)
2055 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2056 material_track->track_id, material_track->sequence->structural_components_count);
2058 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2059 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2063 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2064 if (!source_package) {
2065 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2068 for (k = 0; k < source_package->tracks_count; k++) {
2069 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2070 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2071 ret = AVERROR_INVALIDDATA;
2074 if (temp_track->track_id == component->source_track_id) {
2075 source_track = temp_track;
2079 if (!source_track) {
2080 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2084 for (k = 0; k < mxf->essence_container_data_count; k++) {
2085 MXFEssenceContainerData *essence_data;
2087 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2088 av_log(mxf, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2091 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2092 source_track->body_sid = essence_data->body_sid;
2093 source_track->index_sid = essence_data->index_sid;
2098 if(source_track && component)
2101 if (!source_track || !component || !source_package) {
2102 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2107 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2108 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2109 ret = AVERROR_INVALIDDATA;
2113 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2114 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2115 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2116 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2120 st = avformat_new_stream(mxf->fc, NULL);
2122 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2123 ret = AVERROR(ENOMEM);
2126 st->id = material_track->track_id;
2127 st->priv_data = source_track;
2129 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2130 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2132 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2133 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2134 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2135 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2137 source_track->original_duration = st->duration = component->duration;
2139 if (st->duration == -1)
2140 st->duration = AV_NOPTS_VALUE;
2141 st->start_time = component->start_position;
2142 if (material_track->edit_rate.num <= 0 ||
2143 material_track->edit_rate.den <= 0) {
2144 av_log(mxf->fc, AV_LOG_WARNING,
2145 "Invalid edit rate (%d/%d) found on stream #%d, "
2146 "defaulting to 25/1\n",
2147 material_track->edit_rate.num,
2148 material_track->edit_rate.den, st->index);
2149 material_track->edit_rate = (AVRational){25, 1};
2151 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2153 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2154 * the former is accessible via st->priv_data */
2155 source_track->edit_rate = material_track->edit_rate;
2157 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2158 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2159 st->codecpar->codec_type = codec_ul->id;
2162 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2165 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2166 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2167 essence_container_ul = &descriptor->essence_container_ul;
2168 /* HACK: replacing the original key with mxf_encrypted_essence_container
2169 * is not allowed according to s429-6, try to find correct information anyway */
2170 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2171 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2172 for (k = 0; k < mxf->metadata_sets_count; k++) {
2173 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2174 if (metadata->type == CryptoContext) {
2175 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2181 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2182 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2183 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2184 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2185 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2186 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2189 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2190 avcodec_get_name(st->codecpar->codec_id));
2191 for (k = 0; k < 16; k++) {
2192 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2193 descriptor->essence_codec_ul[k]);
2194 if (!(k+1 & 19) || k == 5)
2195 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2197 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2199 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2200 if (source_package->name && source_package->name[0])
2201 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2202 if (material_track->name && material_track->name[0])
2203 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2205 mxf_parse_physical_source_package(mxf, source_track, st);
2207 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2208 source_track->intra_only = mxf_is_intra_only(descriptor);
2209 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2210 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2211 st->codecpar->codec_id = container_ul->id;
2212 st->codecpar->width = descriptor->width;
2213 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2214 switch (descriptor->frame_layout) {
2216 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2219 /* Every other line is stored and needs to be duplicated. */
2220 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2221 break; /* The correct thing to do here is fall through, but by breaking we might be
2222 able to decode some streams at half the vertical resolution, rather than not al all.
2223 It's also for compatibility with the old behavior. */
2226 case SegmentedFrame:
2227 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2228 case SeparateFields:
2229 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2230 descriptor->video_line_map[0], descriptor->video_line_map[1],
2231 descriptor->field_dominance);
2232 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2233 /* Detect coded field order from VideoLineMap:
2234 * (even, even) => bottom field coded first
2235 * (even, odd) => top field coded first
2236 * (odd, even) => top field coded first
2237 * (odd, odd) => bottom field coded first
2239 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2240 switch (descriptor->field_dominance) {
2241 case MXF_FIELD_DOMINANCE_DEFAULT:
2242 case MXF_FIELD_DOMINANCE_FF:
2243 st->codecpar->field_order = AV_FIELD_TT;
2245 case MXF_FIELD_DOMINANCE_FL:
2246 st->codecpar->field_order = AV_FIELD_TB;
2249 avpriv_request_sample(mxf->fc,
2250 "Field dominance %d support",
2251 descriptor->field_dominance);
2254 switch (descriptor->field_dominance) {
2255 case MXF_FIELD_DOMINANCE_DEFAULT:
2256 case MXF_FIELD_DOMINANCE_FF:
2257 st->codecpar->field_order = AV_FIELD_BB;
2259 case MXF_FIELD_DOMINANCE_FL:
2260 st->codecpar->field_order = AV_FIELD_BT;
2263 avpriv_request_sample(mxf->fc,
2264 "Field dominance %d support",
2265 descriptor->field_dominance);
2269 /* Turn field height into frame height. */
2270 st->codecpar->height *= 2;
2273 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2275 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2276 st->codecpar->format = descriptor->pix_fmt;
2277 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2278 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2279 &descriptor->essence_codec_ul);
2280 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2281 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2282 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2283 &descriptor->essence_codec_ul)->id;
2284 if (!st->codecpar->codec_tag) {
2285 /* support files created before RP224v10 by defaulting to UYVY422
2286 if subsampling is 4:2:2 and component depth is 8-bit */
2287 if (descriptor->horiz_subsampling == 2 &&
2288 descriptor->vert_subsampling == 1 &&
2289 descriptor->component_depth == 8) {
2290 st->codecpar->format = AV_PIX_FMT_UYVY422;
2296 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2297 if (material_track->sequence->origin) {
2298 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2300 if (source_track->sequence->origin) {
2301 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2303 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2304 st->display_aspect_ratio = descriptor->aspect_ratio;
2305 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2306 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2307 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2308 if (st->codecpar->codec_id == AV_CODEC_ID_NONE || (st->codecpar->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
2309 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2310 st->codecpar->channels = descriptor->channels;
2311 st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2313 if (descriptor->sample_rate.den > 0) {
2314 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2315 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2317 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2318 "found for stream #%d, time base forced to 1/48000\n",
2319 descriptor->sample_rate.num, descriptor->sample_rate.den,
2321 avpriv_set_pts_info(st, 64, 1, 48000);
2324 /* if duration is set, rescale it from EditRate to SampleRate */
2325 if (st->duration != AV_NOPTS_VALUE)
2326 st->duration = av_rescale_q(st->duration,
2327 av_inv_q(material_track->edit_rate),
2330 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2331 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2332 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2333 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2334 else if (descriptor->bits_per_sample == 32)
2335 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2336 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2337 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2338 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2339 else if (descriptor->bits_per_sample == 32)
2340 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2341 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2342 st->need_parsing = AVSTREAM_PARSE_FULL;
2344 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2345 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2346 essence_container_ul)->id;
2347 if (codec_id >= 0 &&
2348 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2349 av_dict_set(&st->metadata, "data_type",
2350 mxf_data_essence_descriptor[codec_id], 0);
2353 if (descriptor->extradata) {
2354 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2355 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2357 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2358 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2359 &descriptor->essence_codec_ul)->id;
2361 st->codecpar->width = coded_width;
2362 ret = ff_generate_avci_extradata(st);
2366 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2367 /* TODO: decode timestamps */
2368 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2377 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2379 struct tm time = { 0 };
2380 time.tm_year = (timestamp >> 48) - 1900;
2381 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2382 time.tm_mday = (timestamp >> 32 & 0xFF);
2383 time.tm_hour = (timestamp >> 24 & 0xFF);
2384 time.tm_min = (timestamp >> 16 & 0xFF);
2385 time.tm_sec = (timestamp >> 8 & 0xFF);
2387 /* msvcrt versions of strftime calls the invalid parameter handler
2388 * (aborting the process if one isn't set) if the parameters are out
2390 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2391 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2392 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2393 time.tm_min = av_clip(time.tm_min, 0, 59);
2394 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2396 return (int64_t)av_timegm(&time) * 1000000;
2399 #define SET_STR_METADATA(pb, name, str) do { \
2400 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2402 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2405 #define SET_UID_METADATA(pb, name, var, str) do { \
2406 avio_read(pb, var, 16); \
2407 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2409 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2412 #define SET_TS_METADATA(pb, name, var, str) do { \
2413 var = avio_rb64(pb); \
2414 if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2418 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2420 MXFContext *mxf = arg;
2421 AVFormatContext *s = mxf->fc;
2428 SET_STR_METADATA(pb, "company_name", str);
2431 SET_STR_METADATA(pb, "product_name", str);
2434 SET_STR_METADATA(pb, "product_version", str);
2437 SET_UID_METADATA(pb, "product_uid", uid, str);
2440 SET_TS_METADATA(pb, "modification_date", ts, str);
2443 SET_STR_METADATA(pb, "application_platform", str);
2446 SET_UID_METADATA(pb, "generation_uid", uid, str);
2449 SET_UID_METADATA(pb, "uid", uid, str);
2455 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2457 MXFContext *mxf = arg;
2458 AVFormatContext *s = mxf->fc;
2462 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2463 SET_STR_METADATA(pb, "project_name", str);
2468 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2469 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2470 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2471 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2472 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2473 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2474 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2475 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2476 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2477 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2478 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2479 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2480 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2481 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2482 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2483 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2484 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2485 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2486 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2487 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2488 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2489 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2490 { { 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 */
2491 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2492 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2493 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2494 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2495 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2496 { { 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 */
2497 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2498 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2499 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2500 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2501 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2502 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2503 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2504 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2505 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2508 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2511 case MultipleDescriptor:
2513 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2514 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2522 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2524 AVIOContext *pb = mxf->fc->pb;
2525 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2526 uint64_t klv_end = avio_tell(pb) + klv->length;
2529 return AVERROR(ENOMEM);
2530 mxf_metadataset_init(ctx, type);
2531 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2533 int tag = avio_rb16(pb);
2534 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2535 uint64_t next = avio_tell(pb) + size;
2538 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2539 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2540 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2543 if (tag > 0x7FFF) { /* dynamic tag */
2545 for (i = 0; i < mxf->local_tags_count; i++) {
2546 int local_tag = AV_RB16(mxf->local_tags+i*18);
2547 if (local_tag == tag) {
2548 memcpy(uid, mxf->local_tags+i*18+2, 16);
2549 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2550 PRINT_KEY(mxf->fc, "uid", uid);
2554 if (ctx_size && tag == 0x3C0A) {
2555 avio_read(pb, ctx->uid, 16);
2556 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2557 mxf_free_metadataset(&ctx, !!ctx_size);
2561 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2562 * it extending past the end of the KLV though (zzuf5.mxf). */
2563 if (avio_tell(pb) > klv_end) {
2566 mxf_free_metadataset(&ctx, !!ctx_size);
2569 av_log(mxf->fc, AV_LOG_ERROR,
2570 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2572 return AVERROR_INVALIDDATA;
2573 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2574 avio_seek(pb, next, SEEK_SET);
2576 if (ctx_size) ctx->type = type;
2577 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2581 * Matches any partition pack key, in other words:
2585 * @return non-zero if the key is a partition pack key, zero otherwise
2587 static int mxf_is_partition_pack_key(UID key)
2589 //NOTE: this is a little lax since it doesn't constraint key[14]
2590 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2591 key[13] >= 2 && key[13] <= 4;
2595 * Parses a metadata KLV
2596 * @return <0 on error, 0 otherwise
2598 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2599 int ctx_size, enum MXFMetadataSetType type)
2601 AVFormatContext *s = mxf->fc;
2603 if (klv.key[5] == 0x53) {
2604 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2606 uint64_t next = avio_tell(s->pb) + klv.length;
2607 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2609 /* only seek forward, else this can loop for a long time */
2610 if (avio_tell(s->pb) > next) {
2611 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2613 return AVERROR_INVALIDDATA;
2616 avio_seek(s->pb, next, SEEK_SET);
2619 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2626 * Seeks to the previous partition and parses it, if possible
2627 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2629 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2631 AVIOContext *pb = mxf->fc->pb;
2633 int64_t current_partition_ofs;
2636 if (!mxf->current_partition ||
2637 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2638 return 0; /* we've parsed all partitions */
2640 /* seek to previous partition */
2641 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2642 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2643 mxf->current_partition = NULL;
2645 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2647 /* Make sure this is actually a PartitionPack, and if so parse it.
2650 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2651 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2655 if (!mxf_is_partition_pack_key(klv.key)) {
2656 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2657 return AVERROR_INVALIDDATA;
2660 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2661 * can point to just before the current partition, causing klv_read_packet()
2662 * to sync back up to it. See deadlock3.mxf
2664 if (klv.offset >= current_partition_ofs) {
2665 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2666 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2667 return AVERROR_INVALIDDATA;
2670 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2677 * Called when essence is encountered
2678 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2680 static int mxf_parse_handle_essence(MXFContext *mxf)
2682 AVIOContext *pb = mxf->fc->pb;
2685 if (mxf->parsing_backward) {
2686 return mxf_seek_to_previous_partition(mxf);
2688 if (!mxf->footer_partition) {
2689 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2693 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2695 /* remember where we were so we don't end up seeking further back than this */
2696 mxf->last_forward_tell = avio_tell(pb);
2698 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2699 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2703 /* seek to FooterPartition and parse backward */
2704 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2705 av_log(mxf->fc, AV_LOG_ERROR,
2706 "failed to seek to FooterPartition @ 0x%" PRIx64
2707 " (%"PRId64") - partial file?\n",
2708 mxf->run_in + mxf->footer_partition, ret);
2712 mxf->current_partition = NULL;
2713 mxf->parsing_backward = 1;
2720 * Called when the next partition or EOF is encountered
2721 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2723 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2725 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2729 * Figures out the proper offset and length of the essence container in each partition
2731 static void mxf_compute_essence_containers(MXFContext *mxf)
2735 /* everything is already correct */
2736 if (mxf->op == OPAtom)
2739 for (x = 0; x < mxf->partitions_count; x++) {
2740 MXFPartition *p = &mxf->partitions[x];
2743 continue; /* BodySID == 0 -> no essence */
2745 if (x >= mxf->partitions_count - 1)
2746 break; /* FooterPartition - can't compute length (and we don't need to) */
2748 /* essence container spans to the next partition */
2749 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2751 if (p->essence_length < 0) {
2752 /* next ThisPartition < essence_offset */
2753 p->essence_length = 0;
2754 av_log(mxf->fc, AV_LOG_ERROR,
2755 "partition %i: bad ThisPartition = %"PRIX64"\n",
2756 x+1, mxf->partitions[x+1].this_partition);
2761 static int64_t round_to_kag(int64_t position, int kag_size)
2763 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2764 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2765 int64_t ret = (position / kag_size) * kag_size;
2766 return ret == position ? ret : ret + kag_size;
2769 static int is_pcm(enum AVCodecID codec_id)
2771 /* we only care about "normal" PCM codecs until we get samples */
2772 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2775 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2779 if (mxf->op != OPAtom)
2782 for (i = 0; i < mxf->fc->nb_streams; i++) {
2783 if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2785 return mxf->fc->streams[i];
2791 * Deal with the case where for some audio atoms EditUnitByteCount is
2792 * very small (2, 4..). In those cases we should read more than one
2793 * sample per call to mxf_read_packet().
2795 static void mxf_handle_small_eubc(AVFormatContext *s)
2797 MXFContext *mxf = s->priv_data;
2800 /* assuming non-OPAtom == frame wrapped
2801 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2802 AVStream *st = mxf_get_opatom_stream(mxf);
2806 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2807 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2808 !is_pcm(st->codecpar->codec_id) ||
2809 mxf->nb_index_tables != 1 ||
2810 mxf->index_tables[0].nb_segments != 1 ||
2811 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2814 /* arbitrarily default to 48 kHz PAL audio frame size */
2815 /* TODO: We could compute this from the ratio between the audio
2816 * and video edit rates for 48 kHz NTSC we could use the
2817 * 1802-1802-1802-1802-1801 pattern. */
2818 track = st->priv_data;
2819 mxf->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2823 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2825 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2827 AVFormatContext *s = mxf->fc;
2828 AVStream *st = NULL;
2829 MXFIndexTableSegment *segment = NULL;
2830 MXFPartition *p = NULL;
2831 int essence_partition_count = 0;
2834 st = mxf_get_opatom_stream(mxf);
2838 /* TODO: support raw video without an index if they exist */
2839 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2842 /* check if file already has a IndexTableSegment */
2843 for (i = 0; i < mxf->metadata_sets_count; i++) {
2844 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2848 /* find the essence partition */
2849 for (i = 0; i < mxf->partitions_count; i++) {
2850 /* BodySID == 0 -> no essence */
2851 if (!mxf->partitions[i].body_sid)
2854 p = &mxf->partitions[i];
2855 essence_partition_count++;
2858 /* only handle files with a single essence partition */
2859 if (essence_partition_count != 1)
2862 if (!(segment = av_mallocz(sizeof(*segment))))
2863 return AVERROR(ENOMEM);
2865 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2866 mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2870 segment->type = IndexTableSegment;
2871 /* stream will be treated as small EditUnitByteCount */
2872 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2873 segment->index_start_position = 0;
2874 segment->index_duration = s->streams[0]->duration;
2875 segment->index_sid = p->index_sid;
2876 segment->body_sid = p->body_sid;
2880 static void mxf_read_random_index_pack(AVFormatContext *s)
2882 MXFContext *mxf = s->priv_data;
2884 int64_t file_size, max_rip_length, min_rip_length;
2887 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2890 file_size = avio_size(s->pb);
2892 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2893 * The limit below assumes a file with nothing but partition packs and a RIP.
2894 * Before changing this, consider that a muxer may place each sample in its own partition.
2896 * 105 is the size of the smallest possible PartitionPack
2897 * 12 is the size of each RIP entry
2898 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2900 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2901 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2903 /* We're only interested in RIPs with at least two entries.. */
2904 min_rip_length = 16+1+24+4;
2906 /* See S377m section 11 */
2907 avio_seek(s->pb, file_size - 4, SEEK_SET);
2908 length = avio_rb32(s->pb);
2910 if (length < min_rip_length || length > max_rip_length)
2912 avio_seek(s->pb, file_size - length, SEEK_SET);
2913 if (klv_read_packet(&klv, s->pb) < 0 ||
2914 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2915 klv.length != length - 20)
2918 avio_skip(s->pb, klv.length - 12);
2919 mxf->footer_partition = avio_rb64(s->pb);
2922 if (mxf->run_in + mxf->footer_partition >= file_size) {
2923 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2924 mxf->footer_partition = 0;
2928 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2931 static int mxf_read_header(AVFormatContext *s)
2933 MXFContext *mxf = s->priv_data;
2935 int64_t essence_offset = 0;
2938 mxf->last_forward_tell = INT64_MAX;
2939 mxf->edit_units_per_packet = 1;
2941 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2942 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2943 return AVERROR_INVALIDDATA;
2945 avio_seek(s->pb, -14, SEEK_CUR);
2947 mxf->run_in = avio_tell(s->pb);
2949 mxf_read_random_index_pack(s);
2951 while (!avio_feof(s->pb)) {
2952 const MXFMetadataReadTableEntry *metadata;
2954 if (klv_read_packet(&klv, s->pb) < 0) {
2955 /* EOF - seek to previous partition or stop */
2956 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2962 PRINT_KEY(s, "read header", klv.key);
2963 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2964 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2965 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2966 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2967 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
2968 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
2970 if (!mxf->current_partition) {
2971 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2972 return AVERROR_INVALIDDATA;
2975 if (!mxf->current_partition->essence_offset) {
2976 /* for OP1a we compute essence_offset
2977 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2978 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2979 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2981 int64_t op1a_essence_offset =
2982 mxf->current_partition->this_partition +
2983 round_to_kag(mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2984 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2985 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2987 if (mxf->op == OPAtom) {
2988 /* point essence_offset to the actual data
2989 * OPAtom has all the essence in one big KLV
2991 mxf->current_partition->essence_offset = avio_tell(s->pb);
2992 mxf->current_partition->essence_length = klv.length;
2994 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2995 if (IS_KLV_KEY(klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(klv.key, mxf_system_item_key_gc))
2996 mxf->current_partition->essence_offset = klv.offset;
2998 mxf->current_partition->essence_offset = op1a_essence_offset;
3002 if (!essence_offset)
3003 essence_offset = klv.offset;
3005 /* seek to footer, previous partition or stop */
3006 if (mxf_parse_handle_essence(mxf) <= 0)
3009 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3010 /* next partition pack - keep going, seek to previous partition or stop */
3011 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3013 else if (mxf->parsing_backward)
3015 /* we're still parsing forward. proceed to parsing this partition pack */
3018 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3019 if (IS_KLV_KEY(klv.key, metadata->key)) {
3020 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3025 if (!metadata->read) {
3026 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3028 avio_skip(s->pb, klv.length);
3031 /* FIXME avoid seek */
3032 if (!essence_offset) {
3033 av_log(s, AV_LOG_ERROR, "no essence\n");
3034 ret = AVERROR_INVALIDDATA;
3037 avio_seek(s->pb, essence_offset, SEEK_SET);
3039 mxf_compute_essence_containers(mxf);
3041 /* we need to do this before computing the index tables
3042 * to be able to fill in zero IndexDurations with st->duration */
3043 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3046 mxf_handle_missing_index_segment(mxf);
3047 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3050 if (mxf->nb_index_tables > 1) {
3051 /* TODO: look up which IndexSID to use via EssenceContainerData */
3052 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3053 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3054 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
3055 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3056 ret = AVERROR_INVALIDDATA;
3060 mxf_handle_small_eubc(s);
3069 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3072 for (i = 0; i < mxf->nb_index_tables; i++)
3073 if (mxf->index_tables[i].index_sid == index_sid)
3074 return &mxf->index_tables[i];
3078 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3079 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3081 int64_t a, b, m, offset;
3082 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3084 if (!t || track->original_duration <= 0)
3088 b = track->original_duration;
3092 if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
3094 if (offset < current_offset)
3106 * Sets mxf->current_edit_unit based on what offset we're currently at.
3107 * @return next_ofs if OK, <0 on error
3109 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
3111 int64_t last_ofs = -1, next_ofs = -1;
3112 MXFIndexTable *t = &mxf->index_tables[0];
3114 /* this is called from the OP1a demuxing logic, which means there
3115 * may be no index tables */
3116 if (mxf->nb_index_tables <= 0)
3119 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
3120 while (mxf->current_edit_unit >= 0) {
3121 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
3124 if (next_ofs <= last_ofs) {
3125 /* large next_ofs didn't change or current_edit_unit wrapped
3126 * around this fixes the infinite loop on zzuf3.mxf */
3127 av_log(mxf->fc, AV_LOG_ERROR,
3128 "next_ofs didn't change. not deriving packet timestamps\n");
3132 if (next_ofs > current_offset)
3135 last_ofs = next_ofs;
3136 mxf->current_edit_unit++;
3139 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3140 if (mxf->current_edit_unit < 0)
3146 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3147 uint64_t *sample_count)
3149 int i, total = 0, size = 0;
3150 AVStream *st = mxf->fc->streams[stream_index];
3151 MXFTrack *track = st->priv_data;
3152 AVRational time_base = av_inv_q(track->edit_rate);
3153 AVRational sample_rate = av_inv_q(st->time_base);
3154 const MXFSamplesPerFrame *spf = NULL;
3156 if ((sample_rate.num / sample_rate.den) == 48000)
3157 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3159 int remainder = (sample_rate.num * time_base.num) %
3160 (time_base.den * sample_rate.den);
3161 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
3162 av_mul_q(sample_rate, time_base)));
3164 av_log(mxf->fc, AV_LOG_WARNING,
3165 "seeking detected on stream #%d with time base (%d/%d) and "
3166 "sample rate (%d/%d), audio pts won't be accurate.\n",
3167 stream_index, time_base.num, time_base.den,
3168 sample_rate.num, sample_rate.den);
3172 while (spf->samples_per_frame[size]) {
3173 total += spf->samples_per_frame[size];
3179 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3180 for (i = 0; i < mxf->current_edit_unit % size; i++) {
3181 *sample_count += spf->samples_per_frame[i];
3187 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3190 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3191 int64_t bits_per_sample = par->bits_per_coded_sample;
3193 if (!bits_per_sample)
3194 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3196 pkt->pts = track->sample_count;
3198 if ( par->channels <= 0
3199 || bits_per_sample <= 0
3200 || par->channels * (int64_t)bits_per_sample < 8)
3201 return AVERROR(EINVAL);
3202 track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3206 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3208 AVCodecParameters *par = st->codecpar;
3209 MXFTrack *track = st->priv_data;
3211 if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3212 /* mxf->current_edit_unit good - see if we have an
3213 * index table to derive timestamps from */
3214 MXFIndexTable *t = &mxf->index_tables[0];
3216 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3217 pkt->dts = mxf->current_edit_unit + t->first_dts;
3218 pkt->pts = t->ptses[mxf->current_edit_unit];
3219 } else if (track && track->intra_only) {
3220 /* intra-only -> PTS = EditUnit.
3221 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3222 pkt->pts = mxf->current_edit_unit;
3224 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3225 int ret = mxf_set_audio_pts(mxf, par, pkt);
3232 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3235 MXFContext *mxf = s->priv_data;
3238 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3239 PRINT_KEY(s, "read packet", klv.key);
3240 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3241 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3242 ret = mxf_decrypt_triplet(s, pkt, &klv);
3244 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3249 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3250 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3251 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3252 int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3253 int index = mxf_get_stream_index(s, &klv, body_sid);
3254 int64_t next_ofs, next_klv;
3258 av_log(s, AV_LOG_ERROR,
3259 "error getting stream index %"PRIu32"\n",
3260 AV_RB32(klv.key + 12));
3264 st = s->streams[index];
3266 if (s->streams[index]->discard == AVDISCARD_ALL)
3269 next_klv = avio_tell(s->pb) + klv.length;
3270 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3272 if (next_ofs >= 0 && next_klv > next_ofs) {
3273 /* if this check is hit then it's possible OPAtom was treated as OP1a
3274 * truncate the packet since it's probably very large (>2 GiB is common) */
3275 avpriv_request_sample(s,
3276 "OPAtom misinterpreted as OP1a? "
3277 "KLV for edit unit %"PRId64" extending into "
3279 mxf->current_edit_unit);
3280 klv.length = next_ofs - avio_tell(s->pb);
3283 /* check for 8 channels AES3 element */
3284 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3285 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3288 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3292 ret = av_get_packet(s->pb, pkt, klv.length);
3296 pkt->stream_index = index;
3297 pkt->pos = klv.offset;
3299 ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3303 /* seek for truncated packets */
3304 avio_seek(s->pb, next_klv, SEEK_SET);
3309 avio_skip(s->pb, klv.length);
3311 return avio_feof(s->pb) ? AVERROR_EOF : ret;
3314 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3316 MXFContext *mxf = s->priv_data;
3318 int64_t ret64, pos, next_pos;
3324 if (mxf->op != OPAtom)
3325 return mxf_read_packet_old(s, pkt);
3327 // If we have no streams then we basically are at EOF
3328 st = mxf_get_opatom_stream(mxf);
3332 track = st->priv_data;
3334 /* OPAtom - clip wrapped demuxing */
3335 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3336 t = &mxf->index_tables[0];
3338 if (mxf->current_edit_unit >= track->original_duration)
3341 edit_units = FFMIN(mxf->edit_units_per_packet, track->original_duration - mxf->current_edit_unit);
3343 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3346 /* compute size by finding the next edit unit or the end of the essence container
3347 * not pretty, but it works */
3348 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3349 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3350 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3351 return AVERROR_INVALIDDATA;
3354 if ((size = next_pos - pos) <= 0) {
3355 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3356 return AVERROR_INVALIDDATA;
3359 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3362 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3365 pkt->stream_index = st->index;
3367 ret = mxf_set_pts(mxf, st, pkt, next_pos);
3371 mxf->current_edit_unit += edit_units;
3376 static int mxf_read_close(AVFormatContext *s)
3378 MXFContext *mxf = s->priv_data;
3381 av_freep(&mxf->packages_refs);
3382 av_freep(&mxf->essence_container_data_refs);
3384 for (i = 0; i < s->nb_streams; i++)
3385 s->streams[i]->priv_data = NULL;
3387 for (i = 0; i < mxf->metadata_sets_count; i++) {
3388 mxf_free_metadataset(mxf->metadata_sets + i, 1);
3390 av_freep(&mxf->partitions);
3391 av_freep(&mxf->metadata_sets);
3392 av_freep(&mxf->aesc);
3393 av_freep(&mxf->local_tags);
3395 if (mxf->index_tables) {
3396 for (i = 0; i < mxf->nb_index_tables; i++) {
3397 av_freep(&mxf->index_tables[i].segments);
3398 av_freep(&mxf->index_tables[i].ptses);
3399 av_freep(&mxf->index_tables[i].fake_index);
3400 av_freep(&mxf->index_tables[i].offsets);
3403 av_freep(&mxf->index_tables);
3408 static int mxf_probe(AVProbeData *p) {
3409 const uint8_t *bufp = p->buf;
3410 const uint8_t *end = p->buf + p->buf_size;
3412 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3415 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3416 end -= sizeof(mxf_header_partition_pack_key);
3418 for (; bufp < end;) {
3419 if (!((bufp[13] - 1) & 0xF2)){
3420 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3421 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3422 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3423 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3424 return AVPROBE_SCORE_MAX;
3433 /* rudimentary byte seek */
3434 /* XXX: use MXF Index */
3435 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3437 AVStream *st = s->streams[stream_index];
3439 MXFContext* mxf = s->priv_data;
3443 MXFTrack *source_track = st->priv_data;
3445 if(st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
3448 /* if audio then truncate sample_time to EditRate */
3449 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3450 sample_time = av_rescale_q(sample_time, st->time_base,
3451 av_inv_q(source_track->edit_rate));
3453 if (mxf->nb_index_tables <= 0) {
3455 return AVERROR_INVALIDDATA;
3456 if (sample_time < 0)
3458 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3460 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3464 ff_update_cur_dts(s, st, sample_time);
3465 mxf->current_edit_unit = sample_time;
3467 t = &mxf->index_tables[0];
3468 if (t->index_sid != source_track->index_sid) {
3469 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3470 for (i = 0; i < s->nb_streams; i++) {
3471 MXFTrack *new_source_track = s->streams[i]->priv_data;
3472 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3473 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3474 source_track = new_source_track;
3479 if (i == s->nb_streams)
3480 return AVERROR_INVALIDDATA;
3483 /* clamp above zero, else ff_index_search_timestamp() returns negative
3484 * this also means we allow seeking before the start */
3485 sample_time = FFMAX(sample_time, 0);
3487 if (t->fake_index) {
3488 /* The first frames may not be keyframes in presentation order, so
3489 * we have to advance the target to be able to find the first
3490 * keyframe backwards... */
3491 if (!(flags & AVSEEK_FLAG_ANY) &&
3492 (flags & AVSEEK_FLAG_BACKWARD) &&
3493 t->ptses[0] != AV_NOPTS_VALUE &&
3494 sample_time < t->ptses[0] &&
3495 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3496 sample_time = t->ptses[0];
3498 /* behave as if we have a proper index */
3499 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3501 /* get the stored order index from the display order index */
3502 sample_time += t->offsets[sample_time];
3504 /* no IndexEntryArray (one or more CBR segments)
3505 * make sure we don't seek past the end */
3506 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3509 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3512 ff_update_cur_dts(s, st, sample_time);
3513 mxf->current_edit_unit = sample_time;
3514 avio_seek(s->pb, seekpos, SEEK_SET);
3517 // Update all tracks sample count
3518 for (i = 0; i < s->nb_streams; i++) {
3519 AVStream *cur_st = s->streams[i];
3520 MXFTrack *cur_track = cur_st->priv_data;
3521 if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3522 int64_t track_edit_unit;
3523 if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
3524 cur_track->sample_count = av_rescale_q(track_edit_unit,
3525 av_inv_q(cur_track->edit_rate),
3528 uint64_t current_sample_count = 0;
3529 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3532 cur_track->sample_count = current_sample_count;
3539 AVInputFormat ff_mxf_demuxer = {
3541 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3542 .flags = AVFMT_SEEK_TO_PTS,
3543 .priv_data_size = sizeof(MXFContext),
3544 .read_probe = mxf_probe,
3545 .read_header = mxf_read_header,
3546 .read_packet = mxf_read_packet,
3547 .read_close = mxf_read_close,
3548 .read_seek = mxf_read_seek,