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);
375 if (size > INT64_MAX)
376 return AVERROR_INVALIDDATA;
380 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
383 for (i = 0; i < size && !avio_feof(pb); i++) {
387 else if (b != key[i])
393 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
396 if (!mxf_read_sync(pb, mxf_klv_key, 4))
397 return AVERROR_INVALIDDATA;
398 klv->offset = avio_tell(pb) - 4;
399 memcpy(klv->key, mxf_klv_key, 4);
400 avio_read(pb, klv->key + 4, 12);
401 length = klv_decode_ber_length(pb);
404 klv->length = length;
408 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
412 for (i = 0; i < s->nb_streams; i++) {
413 MXFTrack *track = s->streams[i]->priv_data;
415 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)))
418 /* return 0 if only one stream, for OP Atom files with 0 as track number */
419 return s->nb_streams == 1 ? 0 : -1;
422 static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
424 // we look for partition where the offset is placed
426 int64_t this_partition;
429 b = mxf->partitions_count;
433 this_partition = mxf->partitions[m].this_partition;
434 if (this_partition <= offset)
442 return mxf->partitions[a].body_sid;
445 /* XXX: use AVBitStreamFilter */
446 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
448 const uint8_t *buf_ptr, *end_ptr;
452 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
453 return AVERROR_INVALIDDATA;
454 length = av_get_packet(pb, pkt, length);
457 data_ptr = pkt->data;
458 end_ptr = pkt->data + length;
459 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
460 for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
461 for (i = 0; i < st->codecpar->channels; i++) {
462 uint32_t sample = bytestream_get_le32(&buf_ptr);
463 if (st->codecpar->bits_per_coded_sample == 24)
464 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
466 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
468 buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
470 av_shrink_packet(pkt, data_ptr - pkt->data);
474 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
476 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
477 MXFContext *mxf = s->priv_data;
478 AVIOContext *pb = s->pb;
479 int64_t end = avio_tell(pb) + klv->length;
482 uint64_t plaintext_size;
488 if (!mxf->aesc && s->key && s->keylen == 16) {
489 mxf->aesc = av_aes_alloc();
491 return AVERROR(ENOMEM);
492 av_aes_init(mxf->aesc, s->key, 128, 1);
495 size = klv_decode_ber_length(pb);
500 klv_decode_ber_length(pb);
501 plaintext_size = avio_rb64(pb);
503 klv_decode_ber_length(pb);
504 avio_read(pb, klv->key, 16);
505 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
506 return AVERROR_INVALIDDATA;
508 body_sid = find_body_sid_by_offset(mxf, klv->offset);
509 index = mxf_get_stream_index(s, klv, body_sid);
511 return AVERROR_INVALIDDATA;
513 klv_decode_ber_length(pb);
514 orig_size = avio_rb64(pb);
515 if (orig_size < plaintext_size)
516 return AVERROR_INVALIDDATA;
518 size = klv_decode_ber_length(pb);
519 if (size < 32 || size - 32 < orig_size)
520 return AVERROR_INVALIDDATA;
521 avio_read(pb, ivec, 16);
522 avio_read(pb, tmpbuf, 16);
524 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
525 if (memcmp(tmpbuf, checkv, 16))
526 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
528 size = av_get_packet(pb, pkt, size);
531 else if (size < plaintext_size)
532 return AVERROR_INVALIDDATA;
533 size -= plaintext_size;
535 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
536 &pkt->data[plaintext_size], size >> 4, ivec, 1);
537 av_shrink_packet(pkt, orig_size);
538 pkt->stream_index = index;
539 avio_skip(pb, end - avio_tell(pb));
543 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
545 MXFContext *mxf = arg;
546 int item_num = avio_rb32(pb);
547 int item_len = avio_rb32(pb);
549 if (item_len != 18) {
550 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
551 return AVERROR_PATCHWELCOME;
553 if (item_num > 65536 || item_num < 0) {
554 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
555 return AVERROR_INVALIDDATA;
558 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
559 av_free(mxf->local_tags);
560 mxf->local_tags_count = 0;
561 mxf->local_tags = av_calloc(item_num, item_len);
562 if (!mxf->local_tags)
563 return AVERROR(ENOMEM);
564 mxf->local_tags_count = item_num;
565 avio_read(pb, mxf->local_tags, item_num*item_len);
569 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
571 MXFContext *mxf = arg;
572 MXFPartition *partition, *tmp_part;
574 uint64_t footer_partition;
575 uint32_t nb_essence_containers;
577 if (mxf->partitions_count >= INT_MAX / 2)
578 return AVERROR_INVALIDDATA;
580 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
582 return AVERROR(ENOMEM);
583 mxf->partitions = tmp_part;
585 if (mxf->parsing_backward) {
586 /* insert the new partition pack in the middle
587 * this makes the entries in mxf->partitions sorted by offset */
588 memmove(&mxf->partitions[mxf->last_forward_partition+1],
589 &mxf->partitions[mxf->last_forward_partition],
590 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
591 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
593 mxf->last_forward_partition++;
594 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
597 memset(partition, 0, sizeof(*partition));
598 mxf->partitions_count++;
599 partition->pack_length = avio_tell(pb) - klv_offset + size;
600 partition->pack_ofs = klv_offset;
604 partition->type = Header;
607 partition->type = BodyPartition;
610 partition->type = Footer;
613 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
614 return AVERROR_INVALIDDATA;
617 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
618 partition->closed = partition->type == Footer || !(uid[14] & 1);
619 partition->complete = uid[14] > 2;
621 partition->kag_size = avio_rb32(pb);
622 partition->this_partition = avio_rb64(pb);
623 partition->previous_partition = avio_rb64(pb);
624 footer_partition = avio_rb64(pb);
625 partition->header_byte_count = avio_rb64(pb);
626 partition->index_byte_count = avio_rb64(pb);
627 partition->index_sid = avio_rb32(pb);
628 partition->body_offset = avio_rb64(pb);
629 partition->body_sid = avio_rb32(pb);
630 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
631 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
632 return AVERROR_INVALIDDATA;
634 nb_essence_containers = avio_rb32(pb);
636 if (partition->this_partition &&
637 partition->previous_partition == partition->this_partition) {
638 av_log(mxf->fc, AV_LOG_ERROR,
639 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
640 partition->previous_partition);
641 /* override with the actual previous partition offset */
642 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
644 mxf->partitions + mxf->last_forward_partition - 2;
645 partition->previous_partition = prev->this_partition;
647 /* if no previous body partition are found point to the header
649 if (partition->previous_partition == partition->this_partition)
650 partition->previous_partition = 0;
651 av_log(mxf->fc, AV_LOG_ERROR,
652 "Overriding PreviousPartition with %"PRIx64"\n",
653 partition->previous_partition);
656 /* some files don't have FooterPartition set in every partition */
657 if (footer_partition) {
658 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
659 av_log(mxf->fc, AV_LOG_ERROR,
660 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
661 mxf->footer_partition, footer_partition);
663 mxf->footer_partition = footer_partition;
667 av_log(mxf->fc, AV_LOG_TRACE,
668 "PartitionPack: ThisPartition = 0x%"PRIX64
669 ", PreviousPartition = 0x%"PRIX64", "
670 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
671 partition->this_partition,
672 partition->previous_partition, footer_partition,
673 partition->index_sid, partition->body_sid);
675 /* sanity check PreviousPartition if set */
676 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
677 if (partition->previous_partition &&
678 mxf->run_in + partition->previous_partition >= klv_offset) {
679 av_log(mxf->fc, AV_LOG_ERROR,
680 "PreviousPartition points to this partition or forward\n");
681 return AVERROR_INVALIDDATA;
684 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
685 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
686 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
687 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
688 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
689 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
690 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
691 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
692 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
693 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
694 else if (op[12] == 0x10) {
695 /* SMPTE 390m: "There shall be exactly one essence container"
696 * The following block deals with files that violate this, namely:
697 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
698 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
699 if (nb_essence_containers != 1) {
700 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
704 av_log(mxf->fc, AV_LOG_WARNING,
705 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
706 nb_essence_containers,
707 op == OP1a ? "OP1a" : "OPAtom");
713 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
717 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
718 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
719 partition->kag_size);
721 if (mxf->op == OPSONYOpt)
722 partition->kag_size = 512;
724 partition->kag_size = 1;
726 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
732 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
734 MXFMetadataSet **tmp;
736 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
738 return AVERROR(ENOMEM);
739 mxf->metadata_sets = tmp;
740 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
741 mxf->metadata_sets_count++;
745 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
747 MXFCryptoContext *cryptocontext = arg;
749 return AVERROR_INVALIDDATA;
750 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
751 avio_read(pb, cryptocontext->source_container_ul, 16);
755 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
757 *count = avio_rb32(pb);
758 *refs = av_calloc(*count, sizeof(UID));
761 return AVERROR(ENOMEM);
763 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
764 avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
768 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
773 if (size < 0 || size > INT_MAX/2)
774 return AVERROR(EINVAL);
776 buf_size = size + size / 2 + 1;
777 *str = av_malloc(buf_size);
779 return AVERROR(ENOMEM);
782 ret = avio_get_str16be(pb, size, *str, buf_size);
784 ret = avio_get_str16le(pb, size, *str, buf_size);
794 #define READ_STR16(type, big_endian) \
795 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
797 return mxf_read_utf16_string(pb, size, str, big_endian); \
803 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
805 MXFContext *mxf = arg;
808 if (mxf->packages_refs)
809 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
810 av_free(mxf->packages_refs);
811 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
813 av_free(mxf->essence_container_data_refs);
814 return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
819 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
821 MXFStructuralComponent *source_clip = arg;
824 source_clip->duration = avio_rb64(pb);
827 source_clip->start_position = avio_rb64(pb);
830 /* UMID, only get last 16 bytes */
831 avio_read(pb, source_clip->source_package_ul, 16);
832 avio_read(pb, source_clip->source_package_uid, 16);
835 source_clip->source_track_id = avio_rb32(pb);
841 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
843 MXFTimecodeComponent *mxf_timecode = arg;
846 mxf_timecode->start_frame = avio_rb64(pb);
849 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
852 mxf_timecode->drop_frame = avio_r8(pb);
858 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
860 MXFPulldownComponent *mxf_pulldown = arg;
863 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
869 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
871 MXFTrack *track = arg;
874 track->track_id = avio_rb32(pb);
877 avio_read(pb, track->track_number, 4);
880 mxf_read_utf16be_string(pb, size, &track->name);
883 track->edit_rate.num = avio_rb32(pb);
884 track->edit_rate.den = avio_rb32(pb);
887 avio_read(pb, track->sequence_ref, 16);
893 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
895 MXFSequence *sequence = arg;
898 sequence->duration = avio_rb64(pb);
901 avio_read(pb, sequence->data_definition_ul, 16);
904 sequence->origin = avio_r8(pb);
907 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
908 &sequence->structural_components_count);
913 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
915 MXFEssenceGroup *essence_group = arg;
918 essence_group->duration = avio_rb64(pb);
921 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
922 &essence_group->structural_components_count);
927 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
929 MXFPackage *package = arg;
932 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
933 &package->tracks_count);
936 avio_read(pb, package->package_ul, 16);
937 avio_read(pb, package->package_uid, 16);
940 avio_read(pb, package->descriptor_ref, 16);
943 return mxf_read_utf16be_string(pb, size, &package->name);
945 return mxf_read_strong_ref_array(pb, &package->comment_refs,
946 &package->comment_count);
951 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
953 MXFEssenceContainerData *essence_data = arg;
956 /* linked package umid UMID */
957 avio_read(pb, essence_data->package_ul, 16);
958 avio_read(pb, essence_data->package_uid, 16);
961 essence_data->index_sid = avio_rb32(pb);
964 essence_data->body_sid = avio_rb32(pb);
970 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
974 segment->nb_index_entries = avio_rb32(pb);
976 length = avio_rb32(pb);
977 if(segment->nb_index_entries && length < 11)
978 return AVERROR_INVALIDDATA;
980 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
981 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
982 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
983 av_freep(&segment->temporal_offset_entries);
984 av_freep(&segment->flag_entries);
985 return AVERROR(ENOMEM);
988 for (i = 0; i < segment->nb_index_entries; i++) {
990 return AVERROR_INVALIDDATA;
991 segment->temporal_offset_entries[i] = avio_r8(pb);
992 avio_r8(pb); /* KeyFrameOffset */
993 segment->flag_entries[i] = avio_r8(pb);
994 segment->stream_offset_entries[i] = avio_rb64(pb);
995 avio_skip(pb, length - 11);
1000 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1002 MXFIndexTableSegment *segment = arg;
1005 segment->edit_unit_byte_count = avio_rb32(pb);
1006 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1009 segment->index_sid = avio_rb32(pb);
1010 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1013 segment->body_sid = avio_rb32(pb);
1014 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1017 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1018 return mxf_read_index_entry_array(pb, segment);
1020 segment->index_edit_rate.num = avio_rb32(pb);
1021 segment->index_edit_rate.den = avio_rb32(pb);
1022 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1023 segment->index_edit_rate.den);
1026 segment->index_start_position = avio_rb64(pb);
1027 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1030 segment->index_duration = avio_rb64(pb);
1031 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1037 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1039 int code, value, ofs = 0;
1040 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1044 value = avio_r8(pb);
1045 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1048 layout[ofs++] = code;
1049 layout[ofs++] = value;
1051 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1052 } while (code != 0); /* SMPTE 377M E.2.46 */
1054 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1057 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1059 MXFDescriptor *descriptor = arg;
1060 int entry_count, entry_size;
1064 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1065 &descriptor->sub_descriptors_count);
1066 case 0x3002: /* ContainerDuration */
1067 descriptor->duration = avio_rb64(pb);
1070 avio_read(pb, descriptor->essence_container_ul, 16);
1073 avio_read(pb, descriptor->codec_ul, 16);
1076 descriptor->linked_track_id = avio_rb32(pb);
1078 case 0x3201: /* PictureEssenceCoding */
1079 avio_read(pb, descriptor->essence_codec_ul, 16);
1082 descriptor->width = avio_rb32(pb);
1085 descriptor->height = avio_rb32(pb);
1088 descriptor->frame_layout = avio_r8(pb);
1091 entry_count = avio_rb32(pb);
1092 entry_size = avio_rb32(pb);
1093 if (entry_size == 4) {
1094 if (entry_count > 0)
1095 descriptor->video_line_map[0] = avio_rb32(pb);
1097 descriptor->video_line_map[0] = 0;
1098 if (entry_count > 1)
1099 descriptor->video_line_map[1] = avio_rb32(pb);
1101 descriptor->video_line_map[1] = 0;
1103 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1106 descriptor->aspect_ratio.num = avio_rb32(pb);
1107 descriptor->aspect_ratio.den = avio_rb32(pb);
1110 descriptor->field_dominance = avio_r8(pb);
1113 descriptor->component_depth = avio_rb32(pb);
1116 descriptor->horiz_subsampling = avio_rb32(pb);
1119 descriptor->vert_subsampling = avio_rb32(pb);
1122 descriptor->sample_rate.num = avio_rb32(pb);
1123 descriptor->sample_rate.den = avio_rb32(pb);
1125 case 0x3D06: /* SoundEssenceCompression */
1126 avio_read(pb, descriptor->essence_codec_ul, 16);
1129 descriptor->channels = avio_rb32(pb);
1132 descriptor->bits_per_sample = avio_rb32(pb);
1135 mxf_read_pixel_layout(pb, descriptor);
1138 /* Private uid used by SONY C0023S01.mxf */
1139 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1140 if (descriptor->extradata)
1141 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1142 av_free(descriptor->extradata);
1143 descriptor->extradata_size = 0;
1144 descriptor->extradata = av_malloc(size);
1145 if (!descriptor->extradata)
1146 return AVERROR(ENOMEM);
1147 descriptor->extradata_size = size;
1148 avio_read(pb, descriptor->extradata, size);
1150 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1151 uint32_t rsiz = avio_rb16(pb);
1152 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1153 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1154 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1161 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1163 MXFTaggedValue *tagged_value = arg;
1169 avio_read(pb, key, 17);
1170 /* TODO: handle other types of of indirect values */
1171 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1172 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1173 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1174 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1179 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1181 MXFTaggedValue *tagged_value = arg;
1184 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1186 return mxf_read_indirect_value(tagged_value, pb, size);
1192 * Match an uid independently of the version byte and up to len common bytes
1195 static int mxf_match_uid(const UID key, const UID uid, int len)
1198 for (i = 0; i < len; i++) {
1199 if (i != 7 && key[i] != uid[i])
1205 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1207 while (uls->uid[0]) {
1208 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1215 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1221 for (i = 0; i < mxf->metadata_sets_count; i++) {
1222 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1223 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1224 return mxf->metadata_sets[i];
1230 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1231 // video essence container uls
1232 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 },
1233 { { 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 */
1234 { { 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 */
1235 { { 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 */
1236 { { 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 */
1237 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1238 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* uncompressed picture */
1239 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1240 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1241 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1242 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1245 /* EC ULs for intra-only formats */
1246 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1247 { { 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 */
1248 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1251 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1252 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1253 { { 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 */
1254 { { 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 */
1255 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1258 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1259 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1260 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1261 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1262 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1263 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1264 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1267 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1268 // sound essence container uls
1269 { { 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 */
1270 { { 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 */
1271 { { 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 */
1272 { { 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 */
1273 { { 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) */
1274 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1277 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1278 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1279 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1282 static const char * const mxf_data_essence_descriptor[] = {
1283 "vbi_vanc_smpte_436M",
1286 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1288 int i, j, nb_segments = 0;
1289 MXFIndexTableSegment **unsorted_segments;
1290 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1292 /* count number of segments, allocate arrays and copy unsorted segments */
1293 for (i = 0; i < mxf->metadata_sets_count; i++)
1294 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1298 return AVERROR_INVALIDDATA;
1300 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1301 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1302 av_freep(sorted_segments);
1303 av_free(unsorted_segments);
1304 return AVERROR(ENOMEM);
1307 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1308 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1309 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1311 *nb_sorted_segments = 0;
1313 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1314 for (i = 0; i < nb_segments; i++) {
1315 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1316 uint64_t best_index_duration = 0;
1318 for (j = 0; j < nb_segments; j++) {
1319 MXFIndexTableSegment *s = unsorted_segments[j];
1321 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1322 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1323 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1326 s->body_sid > last_body_sid ||
1327 s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1328 s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1330 s->body_sid < best_body_sid ||
1331 s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1332 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1333 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)) {
1335 best_body_sid = s->body_sid;
1336 best_index_sid = s->index_sid;
1337 best_index_start = s->index_start_position;
1338 best_index_duration = s->index_duration;
1342 /* no suitable entry found -> we're done */
1346 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1347 last_body_sid = best_body_sid;
1348 last_index_sid = best_index_sid;
1349 last_index_start = best_index_start;
1352 av_free(unsorted_segments);
1358 * Computes the absolute file offset of the given essence container offset
1360 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1362 MXFPartition *last_p = NULL;
1366 return AVERROR(EINVAL);
1369 b = mxf->partitions_count;
1372 m0 = m = (a + b) >> 1;
1374 while (m < b && mxf->partitions[m].body_sid != body_sid)
1377 if (m < b && mxf->partitions[m].body_offset <= offset)
1384 last_p = &mxf->partitions[a];
1386 if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1387 *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1391 av_log(mxf->fc, AV_LOG_ERROR,
1392 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1395 return AVERROR_INVALIDDATA;
1399 * Returns the end position of the essence container with given BodySID, or zero if unknown
1401 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1406 for (x = 0; x < mxf->partitions_count; x++) {
1407 MXFPartition *p = &mxf->partitions[x];
1409 if (p->body_sid != body_sid)
1412 if (!p->essence_length)
1415 ret = p->essence_offset + p->essence_length;
1421 /* EditUnit -> absolute offset */
1422 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)
1425 int64_t offset_temp = 0;
1427 for (i = 0; i < index_table->nb_segments; i++) {
1428 MXFIndexTableSegment *s = index_table->segments[i];
1430 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1432 if (edit_unit < s->index_start_position + s->index_duration) {
1433 int64_t index = edit_unit - s->index_start_position;
1435 if (s->edit_unit_byte_count)
1436 offset_temp += s->edit_unit_byte_count * index;
1437 else if (s->nb_index_entries) {
1438 if (s->nb_index_entries == 2 * s->index_duration + 1)
1439 index *= 2; /* Avid index */
1441 if (index < 0 || index >= s->nb_index_entries) {
1442 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1443 index_table->index_sid, s->index_start_position);
1444 return AVERROR_INVALIDDATA;
1447 offset_temp = s->stream_offset_entries[index];
1449 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1450 index_table->index_sid, s->index_start_position);
1451 return AVERROR_INVALIDDATA;
1455 *edit_unit_out = edit_unit;
1457 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1459 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1460 offset_temp += s->edit_unit_byte_count * s->index_duration;
1465 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);
1467 return AVERROR_INVALIDDATA;
1470 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1473 int8_t max_temporal_offset = -128;
1476 /* first compute how many entries we have */
1477 for (i = 0; i < index_table->nb_segments; i++) {
1478 MXFIndexTableSegment *s = index_table->segments[i];
1480 if (!s->nb_index_entries) {
1481 index_table->nb_ptses = 0;
1482 return 0; /* no TemporalOffsets */
1485 index_table->nb_ptses += s->index_duration;
1488 /* paranoid check */
1489 if (index_table->nb_ptses <= 0)
1492 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1493 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1494 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1495 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1496 av_freep(&index_table->ptses);
1497 av_freep(&index_table->fake_index);
1498 av_freep(&index_table->offsets);
1499 return AVERROR(ENOMEM);
1502 /* we may have a few bad TemporalOffsets
1503 * make sure the corresponding PTSes don't have the bogus value 0 */
1504 for (x = 0; x < index_table->nb_ptses; x++)
1505 index_table->ptses[x] = AV_NOPTS_VALUE;
1519 * We want to transform it into this:
1530 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1531 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1532 * The latter makes DTS <= PTS.
1534 for (i = x = 0; i < index_table->nb_segments; i++) {
1535 MXFIndexTableSegment *s = index_table->segments[i];
1536 int index_delta = 1;
1537 int n = s->nb_index_entries;
1539 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1540 index_delta = 2; /* Avid index */
1541 /* ignore the last entry - it's the size of the essence container */
1545 for (j = 0; j < n; j += index_delta, x++) {
1546 int offset = s->temporal_offset_entries[j] / index_delta;
1547 int index = x + offset;
1549 if (x >= index_table->nb_ptses) {
1550 av_log(mxf->fc, AV_LOG_ERROR,
1551 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1552 s->nb_index_entries, s->index_duration);
1556 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1558 if (index < 0 || index >= index_table->nb_ptses) {
1559 av_log(mxf->fc, AV_LOG_ERROR,
1560 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1565 index_table->offsets[x] = offset;
1566 index_table->ptses[index] = x;
1567 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1571 /* calculate the fake index table in display order */
1572 for (x = 0; x < index_table->nb_ptses; x++) {
1573 index_table->fake_index[x].timestamp = x;
1574 if (index_table->ptses[x] != AV_NOPTS_VALUE)
1575 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1579 index_table->first_dts = -max_temporal_offset;
1585 * Sorts and collects index table segments into index tables.
1586 * Also computes PTSes if possible.
1588 static int mxf_compute_index_tables(MXFContext *mxf)
1590 int i, j, k, ret, nb_sorted_segments;
1591 MXFIndexTableSegment **sorted_segments = NULL;
1593 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1594 nb_sorted_segments <= 0) {
1595 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1599 /* sanity check and count unique BodySIDs/IndexSIDs */
1600 for (i = 0; i < nb_sorted_segments; i++) {
1601 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1602 mxf->nb_index_tables++;
1603 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1604 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1605 ret = AVERROR_INVALIDDATA;
1606 goto finish_decoding_index;
1610 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1611 sizeof(*mxf->index_tables));
1612 if (!mxf->index_tables) {
1613 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1614 ret = AVERROR(ENOMEM);
1615 goto finish_decoding_index;
1618 /* distribute sorted segments to index tables */
1619 for (i = j = 0; i < nb_sorted_segments; i++) {
1620 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1625 mxf->index_tables[j].nb_segments++;
1628 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1629 MXFIndexTable *t = &mxf->index_tables[j];
1630 MXFTrack *mxf_track = NULL;
1632 t->segments = av_mallocz_array(t->nb_segments,
1633 sizeof(*t->segments));
1636 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1637 " pointer array\n");
1638 ret = AVERROR(ENOMEM);
1639 goto finish_decoding_index;
1642 if (sorted_segments[i]->index_start_position)
1643 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1644 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1646 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1647 t->index_sid = sorted_segments[i]->index_sid;
1648 t->body_sid = sorted_segments[i]->body_sid;
1650 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1651 goto finish_decoding_index;
1653 for (k = 0; k < mxf->fc->nb_streams; k++) {
1654 MXFTrack *track = mxf->fc->streams[k]->priv_data;
1655 if (track && track->index_sid == t->index_sid) {
1661 /* fix zero IndexDurations */
1662 for (k = 0; k < t->nb_segments; k++) {
1663 if (t->segments[k]->index_duration)
1666 if (t->nb_segments > 1)
1667 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1671 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1675 /* assume the first stream's duration is reasonable
1676 * leave index_duration = 0 on further segments in case we have any (unlikely)
1678 t->segments[k]->index_duration = mxf_track->original_duration;
1684 finish_decoding_index:
1685 av_free(sorted_segments);
1689 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1691 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1692 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1693 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1694 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1697 static int mxf_uid_to_str(UID uid, char **str)
1701 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1703 return AVERROR(ENOMEM);
1704 for (i = 0; i < sizeof(UID); i++) {
1705 snprintf(p, 2 + 1, "%.2x", uid[i]);
1707 if (i == 3 || i == 5 || i == 7 || i == 9) {
1708 snprintf(p, 1 + 1, "-");
1715 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1719 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1721 return AVERROR(ENOMEM);
1722 snprintf(p, 2 + 1, "0x");
1724 for (i = 0; i < sizeof(UID); i++) {
1725 snprintf(p, 2 + 1, "%.2X", ul[i]);
1729 for (i = 0; i < sizeof(UID); i++) {
1730 snprintf(p, 2 + 1, "%.2X", uid[i]);
1736 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1742 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1744 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1748 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1750 char buf[AV_TIMECODE_STR_SIZE];
1751 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1756 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1758 MXFStructuralComponent *component = NULL;
1759 MXFPulldownComponent *pulldown = NULL;
1761 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1765 switch (component->type) {
1766 case TimecodeComponent:
1767 return (MXFTimecodeComponent*)component;
1768 case PulldownComponent: /* timcode component may be located on a pulldown component */
1769 pulldown = (MXFPulldownComponent*)component;
1770 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1777 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1779 MXFPackage *package = NULL;
1782 for (i = 0; i < mxf->packages_count; i++) {
1783 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1787 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1793 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1795 MXFDescriptor *sub_descriptor = NULL;
1801 if (descriptor->type == MultipleDescriptor) {
1802 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1803 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1805 if (!sub_descriptor) {
1806 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1809 if (sub_descriptor->linked_track_id == track_id) {
1810 return sub_descriptor;
1813 } else if (descriptor->type == Descriptor)
1819 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1821 MXFStructuralComponent *component = NULL;
1822 MXFPackage *package = NULL;
1823 MXFDescriptor *descriptor = NULL;
1826 if (!essence_group || !essence_group->structural_components_count)
1829 /* essence groups contains multiple representations of the same media,
1830 this return the first components with a valid Descriptor typically index 0 */
1831 for (i =0; i < essence_group->structural_components_count; i++){
1832 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1836 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1839 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1846 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1848 MXFStructuralComponent *component = NULL;
1850 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1853 switch (component->type) {
1857 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1864 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1866 MXFTaggedValue *tag;
1870 for (i = 0; i < package->comment_count; i++) {
1871 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1872 if (!tag || !tag->name || !tag->value)
1875 size = strlen(tag->name) + 8 + 1;
1876 key = av_mallocz(size);
1878 return AVERROR(ENOMEM);
1880 snprintf(key, size, "comment_%s", tag->name);
1881 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1886 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1888 MXFPackage *physical_package = NULL;
1889 MXFTrack *physical_track = NULL;
1890 MXFStructuralComponent *sourceclip = NULL;
1891 MXFTimecodeComponent *mxf_tc = NULL;
1895 int64_t start_position;
1897 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1898 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1902 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1905 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1907 /* the name of physical source package is name of the reel or tape */
1908 if (physical_package->name && physical_package->name[0])
1909 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1911 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1912 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1914 for (j = 0; j < physical_package->tracks_count; j++) {
1915 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1916 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1920 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1921 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1925 if (physical_track->edit_rate.num <= 0 ||
1926 physical_track->edit_rate.den <= 0) {
1927 av_log(mxf->fc, AV_LOG_WARNING,
1928 "Invalid edit rate (%d/%d) found on structural"
1929 " component #%d, defaulting to 25/1\n",
1930 physical_track->edit_rate.num,
1931 physical_track->edit_rate.den, i);
1932 physical_track->edit_rate = (AVRational){25, 1};
1935 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1936 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1939 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1940 /* scale sourceclip start_position to match physical track edit rate */
1941 start_position = av_rescale_q(sourceclip->start_position,
1942 physical_track->edit_rate,
1943 source_track->edit_rate);
1945 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1946 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1956 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
1958 MXFStructuralComponent *component = NULL;
1959 const MXFCodecUL *codec_ul = NULL;
1960 MXFPackage tmp_package;
1964 for (j = 0; j < track->sequence->structural_components_count; j++) {
1965 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
1973 st = avformat_new_stream(mxf->fc, NULL);
1975 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
1976 return AVERROR(ENOMEM);
1979 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
1980 st->codecpar->codec_id = AV_CODEC_ID_NONE;
1981 st->id = track->track_id;
1983 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
1984 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
1985 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
1986 if (track->name && track->name[0])
1987 av_dict_set(&st->metadata, "track_name", track->name, 0);
1989 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
1990 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
1994 static int mxf_parse_structural_metadata(MXFContext *mxf)
1996 MXFPackage *material_package = NULL;
1999 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2000 /* TODO: handle multiple material packages (OP3x) */
2001 for (i = 0; i < mxf->packages_count; i++) {
2002 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2003 if (material_package) break;
2005 if (!material_package) {
2006 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2007 return AVERROR_INVALIDDATA;
2010 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2011 if (material_package->name && material_package->name[0])
2012 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2013 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2015 for (i = 0; i < material_package->tracks_count; i++) {
2016 MXFPackage *source_package = NULL;
2017 MXFTrack *material_track = NULL;
2018 MXFTrack *source_track = NULL;
2019 MXFTrack *temp_track = NULL;
2020 MXFDescriptor *descriptor = NULL;
2021 MXFStructuralComponent *component = NULL;
2022 MXFTimecodeComponent *mxf_tc = NULL;
2023 UID *essence_container_ul = NULL;
2024 const MXFCodecUL *codec_ul = NULL;
2025 const MXFCodecUL *container_ul = NULL;
2026 const MXFCodecUL *pix_fmt_ul = NULL;
2031 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2032 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2036 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2037 mxf_tc = (MXFTimecodeComponent*)component;
2038 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2039 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2040 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2044 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2045 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2049 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2050 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2054 mxf_tc = (MXFTimecodeComponent*)component;
2055 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2056 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2057 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2062 /* TODO: handle multiple source clips, only finds first valid source clip */
2063 if(material_track->sequence->structural_components_count > 1)
2064 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2065 material_track->track_id, material_track->sequence->structural_components_count);
2067 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2068 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2072 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2073 if (!source_package) {
2074 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2077 for (k = 0; k < source_package->tracks_count; k++) {
2078 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2079 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2080 ret = AVERROR_INVALIDDATA;
2083 if (temp_track->track_id == component->source_track_id) {
2084 source_track = temp_track;
2088 if (!source_track) {
2089 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2093 for (k = 0; k < mxf->essence_container_data_count; k++) {
2094 MXFEssenceContainerData *essence_data;
2096 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2097 av_log(mxf, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2100 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2101 source_track->body_sid = essence_data->body_sid;
2102 source_track->index_sid = essence_data->index_sid;
2107 if(source_track && component)
2110 if (!source_track || !component || !source_package) {
2111 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2116 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2117 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2118 ret = AVERROR_INVALIDDATA;
2122 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2123 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2124 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2125 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2129 st = avformat_new_stream(mxf->fc, NULL);
2131 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2132 ret = AVERROR(ENOMEM);
2135 st->id = material_track->track_id;
2136 st->priv_data = source_track;
2138 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2139 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2141 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2142 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2143 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2144 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2146 source_track->original_duration = st->duration = component->duration;
2148 if (st->duration == -1)
2149 st->duration = AV_NOPTS_VALUE;
2150 st->start_time = component->start_position;
2151 if (material_track->edit_rate.num <= 0 ||
2152 material_track->edit_rate.den <= 0) {
2153 av_log(mxf->fc, AV_LOG_WARNING,
2154 "Invalid edit rate (%d/%d) found on stream #%d, "
2155 "defaulting to 25/1\n",
2156 material_track->edit_rate.num,
2157 material_track->edit_rate.den, st->index);
2158 material_track->edit_rate = (AVRational){25, 1};
2160 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2162 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2163 * the former is accessible via st->priv_data */
2164 source_track->edit_rate = material_track->edit_rate;
2166 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2167 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2168 st->codecpar->codec_type = codec_ul->id;
2171 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2174 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2175 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2176 essence_container_ul = &descriptor->essence_container_ul;
2177 /* HACK: replacing the original key with mxf_encrypted_essence_container
2178 * is not allowed according to s429-6, try to find correct information anyway */
2179 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2180 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2181 for (k = 0; k < mxf->metadata_sets_count; k++) {
2182 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2183 if (metadata->type == CryptoContext) {
2184 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2190 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2191 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2192 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2193 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2194 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2195 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2198 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2199 avcodec_get_name(st->codecpar->codec_id));
2200 for (k = 0; k < 16; k++) {
2201 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2202 descriptor->essence_codec_ul[k]);
2203 if (!(k+1 & 19) || k == 5)
2204 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2206 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2208 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2209 if (source_package->name && source_package->name[0])
2210 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2211 if (material_track->name && material_track->name[0])
2212 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2214 mxf_parse_physical_source_package(mxf, source_track, st);
2216 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2217 source_track->intra_only = mxf_is_intra_only(descriptor);
2218 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2219 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2220 st->codecpar->codec_id = container_ul->id;
2221 st->codecpar->width = descriptor->width;
2222 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2223 switch (descriptor->frame_layout) {
2225 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2228 /* Every other line is stored and needs to be duplicated. */
2229 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2230 break; /* The correct thing to do here is fall through, but by breaking we might be
2231 able to decode some streams at half the vertical resolution, rather than not al all.
2232 It's also for compatibility with the old behavior. */
2235 case SegmentedFrame:
2236 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2237 case SeparateFields:
2238 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2239 descriptor->video_line_map[0], descriptor->video_line_map[1],
2240 descriptor->field_dominance);
2241 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2242 /* Detect coded field order from VideoLineMap:
2243 * (even, even) => bottom field coded first
2244 * (even, odd) => top field coded first
2245 * (odd, even) => top field coded first
2246 * (odd, odd) => bottom field coded first
2248 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2249 switch (descriptor->field_dominance) {
2250 case MXF_FIELD_DOMINANCE_DEFAULT:
2251 case MXF_FIELD_DOMINANCE_FF:
2252 st->codecpar->field_order = AV_FIELD_TT;
2254 case MXF_FIELD_DOMINANCE_FL:
2255 st->codecpar->field_order = AV_FIELD_TB;
2258 avpriv_request_sample(mxf->fc,
2259 "Field dominance %d support",
2260 descriptor->field_dominance);
2263 switch (descriptor->field_dominance) {
2264 case MXF_FIELD_DOMINANCE_DEFAULT:
2265 case MXF_FIELD_DOMINANCE_FF:
2266 st->codecpar->field_order = AV_FIELD_BB;
2268 case MXF_FIELD_DOMINANCE_FL:
2269 st->codecpar->field_order = AV_FIELD_BT;
2272 avpriv_request_sample(mxf->fc,
2273 "Field dominance %d support",
2274 descriptor->field_dominance);
2278 /* Turn field height into frame height. */
2279 st->codecpar->height *= 2;
2282 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2284 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2285 st->codecpar->format = descriptor->pix_fmt;
2286 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2287 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2288 &descriptor->essence_codec_ul);
2289 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2290 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2291 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2292 &descriptor->essence_codec_ul)->id;
2293 if (!st->codecpar->codec_tag) {
2294 /* support files created before RP224v10 by defaulting to UYVY422
2295 if subsampling is 4:2:2 and component depth is 8-bit */
2296 if (descriptor->horiz_subsampling == 2 &&
2297 descriptor->vert_subsampling == 1 &&
2298 descriptor->component_depth == 8) {
2299 st->codecpar->format = AV_PIX_FMT_UYVY422;
2305 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2306 if (material_track->sequence->origin) {
2307 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2309 if (source_track->sequence->origin) {
2310 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2312 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2313 st->display_aspect_ratio = descriptor->aspect_ratio;
2314 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2315 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2316 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2317 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))
2318 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2319 st->codecpar->channels = descriptor->channels;
2320 st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2322 if (descriptor->sample_rate.den > 0) {
2323 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2324 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2326 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2327 "found for stream #%d, time base forced to 1/48000\n",
2328 descriptor->sample_rate.num, descriptor->sample_rate.den,
2330 avpriv_set_pts_info(st, 64, 1, 48000);
2333 /* if duration is set, rescale it from EditRate to SampleRate */
2334 if (st->duration != AV_NOPTS_VALUE)
2335 st->duration = av_rescale_q(st->duration,
2336 av_inv_q(material_track->edit_rate),
2339 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2340 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2341 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2342 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2343 else if (descriptor->bits_per_sample == 32)
2344 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2345 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2346 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2347 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2348 else if (descriptor->bits_per_sample == 32)
2349 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2350 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2351 st->need_parsing = AVSTREAM_PARSE_FULL;
2353 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2354 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2355 essence_container_ul)->id;
2356 if (codec_id >= 0 &&
2357 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2358 av_dict_set(&st->metadata, "data_type",
2359 mxf_data_essence_descriptor[codec_id], 0);
2362 if (descriptor->extradata) {
2363 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2364 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2366 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2367 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2368 &descriptor->essence_codec_ul)->id;
2370 st->codecpar->width = coded_width;
2371 ret = ff_generate_avci_extradata(st);
2375 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2376 /* TODO: decode timestamps */
2377 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2386 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2388 struct tm time = { 0 };
2389 time.tm_year = (timestamp >> 48) - 1900;
2390 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2391 time.tm_mday = (timestamp >> 32 & 0xFF);
2392 time.tm_hour = (timestamp >> 24 & 0xFF);
2393 time.tm_min = (timestamp >> 16 & 0xFF);
2394 time.tm_sec = (timestamp >> 8 & 0xFF);
2396 /* msvcrt versions of strftime calls the invalid parameter handler
2397 * (aborting the process if one isn't set) if the parameters are out
2399 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2400 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2401 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2402 time.tm_min = av_clip(time.tm_min, 0, 59);
2403 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2405 return (int64_t)av_timegm(&time) * 1000000;
2408 #define SET_STR_METADATA(pb, name, str) do { \
2409 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2411 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2414 #define SET_UID_METADATA(pb, name, var, str) do { \
2415 avio_read(pb, var, 16); \
2416 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2418 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2421 #define SET_TS_METADATA(pb, name, var, str) do { \
2422 var = avio_rb64(pb); \
2423 if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2427 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2429 MXFContext *mxf = arg;
2430 AVFormatContext *s = mxf->fc;
2437 SET_STR_METADATA(pb, "company_name", str);
2440 SET_STR_METADATA(pb, "product_name", str);
2443 SET_STR_METADATA(pb, "product_version", str);
2446 SET_UID_METADATA(pb, "product_uid", uid, str);
2449 SET_TS_METADATA(pb, "modification_date", ts, str);
2452 SET_STR_METADATA(pb, "application_platform", str);
2455 SET_UID_METADATA(pb, "generation_uid", uid, str);
2458 SET_UID_METADATA(pb, "uid", uid, str);
2464 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2466 MXFContext *mxf = arg;
2467 AVFormatContext *s = mxf->fc;
2471 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2472 SET_STR_METADATA(pb, "project_name", str);
2477 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2478 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2479 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2480 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2481 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2482 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2483 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2484 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2485 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2486 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2487 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2488 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2489 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2490 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2491 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2492 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2493 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2494 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2495 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2496 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2497 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2498 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2499 { { 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 */
2500 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2501 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2502 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2503 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2504 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2505 { { 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 */
2506 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2507 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2508 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2509 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2510 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2511 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2512 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2513 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2514 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2517 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2520 case MultipleDescriptor:
2522 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2523 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2531 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2533 AVIOContext *pb = mxf->fc->pb;
2534 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2535 uint64_t klv_end = avio_tell(pb) + klv->length;
2538 return AVERROR(ENOMEM);
2539 mxf_metadataset_init(ctx, type);
2540 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2542 int tag = avio_rb16(pb);
2543 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2544 uint64_t next = avio_tell(pb) + size;
2547 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2548 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2549 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2552 if (tag > 0x7FFF) { /* dynamic tag */
2554 for (i = 0; i < mxf->local_tags_count; i++) {
2555 int local_tag = AV_RB16(mxf->local_tags+i*18);
2556 if (local_tag == tag) {
2557 memcpy(uid, mxf->local_tags+i*18+2, 16);
2558 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2559 PRINT_KEY(mxf->fc, "uid", uid);
2563 if (ctx_size && tag == 0x3C0A) {
2564 avio_read(pb, ctx->uid, 16);
2565 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2566 mxf_free_metadataset(&ctx, !!ctx_size);
2570 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2571 * it extending past the end of the KLV though (zzuf5.mxf). */
2572 if (avio_tell(pb) > klv_end) {
2575 mxf_free_metadataset(&ctx, !!ctx_size);
2578 av_log(mxf->fc, AV_LOG_ERROR,
2579 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2581 return AVERROR_INVALIDDATA;
2582 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2583 avio_seek(pb, next, SEEK_SET);
2585 if (ctx_size) ctx->type = type;
2586 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2590 * Matches any partition pack key, in other words:
2594 * @return non-zero if the key is a partition pack key, zero otherwise
2596 static int mxf_is_partition_pack_key(UID key)
2598 //NOTE: this is a little lax since it doesn't constraint key[14]
2599 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2600 key[13] >= 2 && key[13] <= 4;
2604 * Parses a metadata KLV
2605 * @return <0 on error, 0 otherwise
2607 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2608 int ctx_size, enum MXFMetadataSetType type)
2610 AVFormatContext *s = mxf->fc;
2612 if (klv.key[5] == 0x53) {
2613 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2615 uint64_t next = avio_tell(s->pb) + klv.length;
2616 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2618 /* only seek forward, else this can loop for a long time */
2619 if (avio_tell(s->pb) > next) {
2620 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2622 return AVERROR_INVALIDDATA;
2625 avio_seek(s->pb, next, SEEK_SET);
2628 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2635 * Seeks to the previous partition and parses it, if possible
2636 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2638 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2640 AVIOContext *pb = mxf->fc->pb;
2642 int64_t current_partition_ofs;
2645 if (!mxf->current_partition ||
2646 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2647 return 0; /* we've parsed all partitions */
2649 /* seek to previous partition */
2650 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2651 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2652 mxf->current_partition = NULL;
2654 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2656 /* Make sure this is actually a PartitionPack, and if so parse it.
2659 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2660 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2664 if (!mxf_is_partition_pack_key(klv.key)) {
2665 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2666 return AVERROR_INVALIDDATA;
2669 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2670 * can point to just before the current partition, causing klv_read_packet()
2671 * to sync back up to it. See deadlock3.mxf
2673 if (klv.offset >= current_partition_ofs) {
2674 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2675 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2676 return AVERROR_INVALIDDATA;
2679 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2686 * Called when essence is encountered
2687 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2689 static int mxf_parse_handle_essence(MXFContext *mxf)
2691 AVIOContext *pb = mxf->fc->pb;
2694 if (mxf->parsing_backward) {
2695 return mxf_seek_to_previous_partition(mxf);
2697 if (!mxf->footer_partition) {
2698 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2702 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2704 /* remember where we were so we don't end up seeking further back than this */
2705 mxf->last_forward_tell = avio_tell(pb);
2707 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2708 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2712 /* seek to FooterPartition and parse backward */
2713 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2714 av_log(mxf->fc, AV_LOG_ERROR,
2715 "failed to seek to FooterPartition @ 0x%" PRIx64
2716 " (%"PRId64") - partial file?\n",
2717 mxf->run_in + mxf->footer_partition, ret);
2721 mxf->current_partition = NULL;
2722 mxf->parsing_backward = 1;
2729 * Called when the next partition or EOF is encountered
2730 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2732 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2734 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2738 * Figures out the proper offset and length of the essence container in each partition
2740 static void mxf_compute_essence_containers(MXFContext *mxf)
2744 /* everything is already correct */
2745 if (mxf->op == OPAtom)
2748 for (x = 0; x < mxf->partitions_count; x++) {
2749 MXFPartition *p = &mxf->partitions[x];
2752 continue; /* BodySID == 0 -> no essence */
2754 if (x >= mxf->partitions_count - 1)
2755 break; /* FooterPartition - can't compute length (and we don't need to) */
2757 /* essence container spans to the next partition */
2758 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2760 if (p->essence_length < 0) {
2761 /* next ThisPartition < essence_offset */
2762 p->essence_length = 0;
2763 av_log(mxf->fc, AV_LOG_ERROR,
2764 "partition %i: bad ThisPartition = %"PRIX64"\n",
2765 x+1, mxf->partitions[x+1].this_partition);
2770 static int64_t round_to_kag(int64_t position, int kag_size)
2772 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2773 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2774 int64_t ret = (position / kag_size) * kag_size;
2775 return ret == position ? ret : ret + kag_size;
2778 static int is_pcm(enum AVCodecID codec_id)
2780 /* we only care about "normal" PCM codecs until we get samples */
2781 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2784 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2788 if (mxf->op != OPAtom)
2791 for (i = 0; i < mxf->fc->nb_streams; i++) {
2792 if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2794 return mxf->fc->streams[i];
2800 * Deal with the case where for some audio atoms EditUnitByteCount is
2801 * very small (2, 4..). In those cases we should read more than one
2802 * sample per call to mxf_read_packet().
2804 static void mxf_handle_small_eubc(AVFormatContext *s)
2806 MXFContext *mxf = s->priv_data;
2809 /* assuming non-OPAtom == frame wrapped
2810 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2811 AVStream *st = mxf_get_opatom_stream(mxf);
2815 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2816 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2817 !is_pcm(st->codecpar->codec_id) ||
2818 mxf->nb_index_tables != 1 ||
2819 mxf->index_tables[0].nb_segments != 1 ||
2820 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2823 /* arbitrarily default to 48 kHz PAL audio frame size */
2824 /* TODO: We could compute this from the ratio between the audio
2825 * and video edit rates for 48 kHz NTSC we could use the
2826 * 1802-1802-1802-1802-1801 pattern. */
2827 track = st->priv_data;
2828 mxf->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
2832 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2834 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2836 AVFormatContext *s = mxf->fc;
2837 AVStream *st = NULL;
2838 MXFIndexTableSegment *segment = NULL;
2839 MXFPartition *p = NULL;
2840 int essence_partition_count = 0;
2843 st = mxf_get_opatom_stream(mxf);
2847 /* TODO: support raw video without an index if they exist */
2848 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2851 /* check if file already has a IndexTableSegment */
2852 for (i = 0; i < mxf->metadata_sets_count; i++) {
2853 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2857 /* find the essence partition */
2858 for (i = 0; i < mxf->partitions_count; i++) {
2859 /* BodySID == 0 -> no essence */
2860 if (!mxf->partitions[i].body_sid)
2863 p = &mxf->partitions[i];
2864 essence_partition_count++;
2867 /* only handle files with a single essence partition */
2868 if (essence_partition_count != 1)
2871 if (!(segment = av_mallocz(sizeof(*segment))))
2872 return AVERROR(ENOMEM);
2874 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2875 mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2879 segment->type = IndexTableSegment;
2880 /* stream will be treated as small EditUnitByteCount */
2881 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2882 segment->index_start_position = 0;
2883 segment->index_duration = s->streams[0]->duration;
2884 segment->index_sid = p->index_sid;
2885 segment->body_sid = p->body_sid;
2889 static void mxf_read_random_index_pack(AVFormatContext *s)
2891 MXFContext *mxf = s->priv_data;
2893 int64_t file_size, max_rip_length, min_rip_length;
2896 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2899 file_size = avio_size(s->pb);
2901 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2902 * The limit below assumes a file with nothing but partition packs and a RIP.
2903 * Before changing this, consider that a muxer may place each sample in its own partition.
2905 * 105 is the size of the smallest possible PartitionPack
2906 * 12 is the size of each RIP entry
2907 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2909 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2910 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2912 /* We're only interested in RIPs with at least two entries.. */
2913 min_rip_length = 16+1+24+4;
2915 /* See S377m section 11 */
2916 avio_seek(s->pb, file_size - 4, SEEK_SET);
2917 length = avio_rb32(s->pb);
2919 if (length < min_rip_length || length > max_rip_length)
2921 avio_seek(s->pb, file_size - length, SEEK_SET);
2922 if (klv_read_packet(&klv, s->pb) < 0 ||
2923 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2924 klv.length != length - 20)
2927 avio_skip(s->pb, klv.length - 12);
2928 mxf->footer_partition = avio_rb64(s->pb);
2931 if (mxf->run_in + mxf->footer_partition >= file_size) {
2932 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2933 mxf->footer_partition = 0;
2937 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2940 static int mxf_read_header(AVFormatContext *s)
2942 MXFContext *mxf = s->priv_data;
2944 int64_t essence_offset = 0;
2947 mxf->last_forward_tell = INT64_MAX;
2948 mxf->edit_units_per_packet = 1;
2950 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2951 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2952 return AVERROR_INVALIDDATA;
2954 avio_seek(s->pb, -14, SEEK_CUR);
2956 mxf->run_in = avio_tell(s->pb);
2958 mxf_read_random_index_pack(s);
2960 while (!avio_feof(s->pb)) {
2961 const MXFMetadataReadTableEntry *metadata;
2963 if (klv_read_packet(&klv, s->pb) < 0) {
2964 /* EOF - seek to previous partition or stop */
2965 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2971 PRINT_KEY(s, "read header", klv.key);
2972 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2973 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2974 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2975 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2976 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
2977 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
2979 if (!mxf->current_partition) {
2980 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2981 return AVERROR_INVALIDDATA;
2984 if (!mxf->current_partition->essence_offset) {
2985 /* for OP1a we compute essence_offset
2986 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2987 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2988 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2990 int64_t op1a_essence_offset =
2991 mxf->current_partition->this_partition +
2992 round_to_kag(mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2993 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2994 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2996 if (mxf->op == OPAtom) {
2997 /* point essence_offset to the actual data
2998 * OPAtom has all the essence in one big KLV
3000 mxf->current_partition->essence_offset = avio_tell(s->pb);
3001 mxf->current_partition->essence_length = klv.length;
3003 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
3004 if (IS_KLV_KEY(klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(klv.key, mxf_system_item_key_gc))
3005 mxf->current_partition->essence_offset = klv.offset;
3007 mxf->current_partition->essence_offset = op1a_essence_offset;
3011 if (!essence_offset)
3012 essence_offset = klv.offset;
3014 /* seek to footer, previous partition or stop */
3015 if (mxf_parse_handle_essence(mxf) <= 0)
3018 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3019 /* next partition pack - keep going, seek to previous partition or stop */
3020 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3022 else if (mxf->parsing_backward)
3024 /* we're still parsing forward. proceed to parsing this partition pack */
3027 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3028 if (IS_KLV_KEY(klv.key, metadata->key)) {
3029 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3034 if (!metadata->read) {
3035 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3037 avio_skip(s->pb, klv.length);
3040 /* FIXME avoid seek */
3041 if (!essence_offset) {
3042 av_log(s, AV_LOG_ERROR, "no essence\n");
3043 ret = AVERROR_INVALIDDATA;
3046 avio_seek(s->pb, essence_offset, SEEK_SET);
3048 mxf_compute_essence_containers(mxf);
3050 /* we need to do this before computing the index tables
3051 * to be able to fill in zero IndexDurations with st->duration */
3052 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3055 mxf_handle_missing_index_segment(mxf);
3056 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3059 if (mxf->nb_index_tables > 1) {
3060 /* TODO: look up which IndexSID to use via EssenceContainerData */
3061 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3062 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3063 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
3064 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3065 ret = AVERROR_INVALIDDATA;
3069 mxf_handle_small_eubc(s);
3078 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3081 for (i = 0; i < mxf->nb_index_tables; i++)
3082 if (mxf->index_tables[i].index_sid == index_sid)
3083 return &mxf->index_tables[i];
3087 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3088 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3090 int64_t a, b, m, offset;
3091 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3093 if (!t || track->original_duration <= 0)
3097 b = track->original_duration;
3101 if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
3103 if (offset < current_offset)
3115 * Sets mxf->current_edit_unit based on what offset we're currently at.
3116 * @return next_ofs if OK, <0 on error
3118 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
3120 int64_t last_ofs = -1, next_ofs = -1;
3121 MXFIndexTable *t = &mxf->index_tables[0];
3123 /* this is called from the OP1a demuxing logic, which means there
3124 * may be no index tables */
3125 if (mxf->nb_index_tables <= 0)
3128 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
3129 while (mxf->current_edit_unit >= 0) {
3130 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
3133 if (next_ofs <= last_ofs) {
3134 /* large next_ofs didn't change or current_edit_unit wrapped
3135 * around this fixes the infinite loop on zzuf3.mxf */
3136 av_log(mxf->fc, AV_LOG_ERROR,
3137 "next_ofs didn't change. not deriving packet timestamps\n");
3141 if (next_ofs > current_offset)
3144 last_ofs = next_ofs;
3145 mxf->current_edit_unit++;
3148 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3149 if (mxf->current_edit_unit < 0)
3155 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3156 uint64_t *sample_count)
3158 int i, total = 0, size = 0;
3159 AVStream *st = mxf->fc->streams[stream_index];
3160 MXFTrack *track = st->priv_data;
3161 AVRational time_base = av_inv_q(track->edit_rate);
3162 AVRational sample_rate = av_inv_q(st->time_base);
3163 const MXFSamplesPerFrame *spf = NULL;
3165 if ((sample_rate.num / sample_rate.den) == 48000)
3166 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3168 int remainder = (sample_rate.num * time_base.num) %
3169 (time_base.den * sample_rate.den);
3170 *sample_count = av_rescale_q(mxf->current_edit_unit, sample_rate, track->edit_rate);
3172 av_log(mxf->fc, AV_LOG_WARNING,
3173 "seeking detected on stream #%d with time base (%d/%d) and "
3174 "sample rate (%d/%d), audio pts won't be accurate.\n",
3175 stream_index, time_base.num, time_base.den,
3176 sample_rate.num, sample_rate.den);
3180 while (spf->samples_per_frame[size]) {
3181 total += spf->samples_per_frame[size];
3187 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3188 for (i = 0; i < mxf->current_edit_unit % size; i++) {
3189 *sample_count += spf->samples_per_frame[i];
3195 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3198 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3199 int64_t bits_per_sample = par->bits_per_coded_sample;
3201 if (!bits_per_sample)
3202 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3204 pkt->pts = track->sample_count;
3206 if ( par->channels <= 0
3207 || bits_per_sample <= 0
3208 || par->channels * (int64_t)bits_per_sample < 8)
3209 return AVERROR(EINVAL);
3210 track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3214 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3216 AVCodecParameters *par = st->codecpar;
3217 MXFTrack *track = st->priv_data;
3219 if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3220 /* mxf->current_edit_unit good - see if we have an
3221 * index table to derive timestamps from */
3222 MXFIndexTable *t = &mxf->index_tables[0];
3224 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3225 pkt->dts = mxf->current_edit_unit + t->first_dts;
3226 pkt->pts = t->ptses[mxf->current_edit_unit];
3227 } else if (track && track->intra_only) {
3228 /* intra-only -> PTS = EditUnit.
3229 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3230 pkt->pts = mxf->current_edit_unit;
3232 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3233 int ret = mxf_set_audio_pts(mxf, par, pkt);
3240 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3243 MXFContext *mxf = s->priv_data;
3246 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3247 PRINT_KEY(s, "read packet", klv.key);
3248 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3249 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3250 ret = mxf_decrypt_triplet(s, pkt, &klv);
3252 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3257 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3258 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3259 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3260 int body_sid = find_body_sid_by_offset(mxf, klv.offset);
3261 int index = mxf_get_stream_index(s, &klv, body_sid);
3262 int64_t next_ofs, next_klv;
3266 av_log(s, AV_LOG_ERROR,
3267 "error getting stream index %"PRIu32"\n",
3268 AV_RB32(klv.key + 12));
3272 st = s->streams[index];
3274 if (s->streams[index]->discard == AVDISCARD_ALL)
3277 next_klv = avio_tell(s->pb) + klv.length;
3278 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3280 if (next_ofs >= 0 && next_klv > next_ofs) {
3281 /* if this check is hit then it's possible OPAtom was treated as OP1a
3282 * truncate the packet since it's probably very large (>2 GiB is common) */
3283 avpriv_request_sample(s,
3284 "OPAtom misinterpreted as OP1a? "
3285 "KLV for edit unit %"PRId64" extending into "
3287 mxf->current_edit_unit);
3288 klv.length = next_ofs - avio_tell(s->pb);
3291 /* check for 8 channels AES3 element */
3292 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3293 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3296 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3300 ret = av_get_packet(s->pb, pkt, klv.length);
3304 pkt->stream_index = index;
3305 pkt->pos = klv.offset;
3307 ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3311 /* seek for truncated packets */
3312 avio_seek(s->pb, next_klv, SEEK_SET);
3317 avio_skip(s->pb, klv.length);
3319 return avio_feof(s->pb) ? AVERROR_EOF : ret;
3322 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3324 MXFContext *mxf = s->priv_data;
3326 int64_t ret64, pos, next_pos;
3332 if (mxf->op != OPAtom)
3333 return mxf_read_packet_old(s, pkt);
3335 // If we have no streams then we basically are at EOF
3336 st = mxf_get_opatom_stream(mxf);
3340 track = st->priv_data;
3342 /* OPAtom - clip wrapped demuxing */
3343 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3344 t = &mxf->index_tables[0];
3346 if (mxf->current_edit_unit >= track->original_duration)
3349 edit_units = FFMIN(mxf->edit_units_per_packet, track->original_duration - mxf->current_edit_unit);
3351 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3354 /* compute size by finding the next edit unit or the end of the essence container
3355 * not pretty, but it works */
3356 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3357 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3358 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3359 return AVERROR_INVALIDDATA;
3362 if ((size = next_pos - pos) <= 0) {
3363 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3364 return AVERROR_INVALIDDATA;
3367 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3370 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3373 pkt->stream_index = st->index;
3375 ret = mxf_set_pts(mxf, st, pkt, next_pos);
3379 mxf->current_edit_unit += edit_units;
3384 static int mxf_read_close(AVFormatContext *s)
3386 MXFContext *mxf = s->priv_data;
3389 av_freep(&mxf->packages_refs);
3390 av_freep(&mxf->essence_container_data_refs);
3392 for (i = 0; i < s->nb_streams; i++)
3393 s->streams[i]->priv_data = NULL;
3395 for (i = 0; i < mxf->metadata_sets_count; i++) {
3396 mxf_free_metadataset(mxf->metadata_sets + i, 1);
3398 av_freep(&mxf->partitions);
3399 av_freep(&mxf->metadata_sets);
3400 av_freep(&mxf->aesc);
3401 av_freep(&mxf->local_tags);
3403 if (mxf->index_tables) {
3404 for (i = 0; i < mxf->nb_index_tables; i++) {
3405 av_freep(&mxf->index_tables[i].segments);
3406 av_freep(&mxf->index_tables[i].ptses);
3407 av_freep(&mxf->index_tables[i].fake_index);
3408 av_freep(&mxf->index_tables[i].offsets);
3411 av_freep(&mxf->index_tables);
3416 static int mxf_probe(AVProbeData *p) {
3417 const uint8_t *bufp = p->buf;
3418 const uint8_t *end = p->buf + p->buf_size;
3420 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3423 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3424 end -= sizeof(mxf_header_partition_pack_key);
3426 for (; bufp < end;) {
3427 if (!((bufp[13] - 1) & 0xF2)){
3428 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3429 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3430 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3431 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3432 return AVPROBE_SCORE_MAX;
3441 /* rudimentary byte seek */
3442 /* XXX: use MXF Index */
3443 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3445 AVStream *st = s->streams[stream_index];
3447 MXFContext* mxf = s->priv_data;
3451 MXFTrack *source_track = st->priv_data;
3453 if(st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
3456 /* if audio then truncate sample_time to EditRate */
3457 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3458 sample_time = av_rescale_q(sample_time, st->time_base,
3459 av_inv_q(source_track->edit_rate));
3461 if (mxf->nb_index_tables <= 0) {
3463 return AVERROR_INVALIDDATA;
3464 if (sample_time < 0)
3466 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3468 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3472 ff_update_cur_dts(s, st, sample_time);
3473 mxf->current_edit_unit = sample_time;
3475 t = &mxf->index_tables[0];
3476 if (t->index_sid != source_track->index_sid) {
3477 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3478 for (i = 0; i < s->nb_streams; i++) {
3479 MXFTrack *new_source_track = s->streams[i]->priv_data;
3480 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3481 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3482 source_track = new_source_track;
3487 if (i == s->nb_streams)
3488 return AVERROR_INVALIDDATA;
3491 /* clamp above zero, else ff_index_search_timestamp() returns negative
3492 * this also means we allow seeking before the start */
3493 sample_time = FFMAX(sample_time, 0);
3495 if (t->fake_index) {
3496 /* The first frames may not be keyframes in presentation order, so
3497 * we have to advance the target to be able to find the first
3498 * keyframe backwards... */
3499 if (!(flags & AVSEEK_FLAG_ANY) &&
3500 (flags & AVSEEK_FLAG_BACKWARD) &&
3501 t->ptses[0] != AV_NOPTS_VALUE &&
3502 sample_time < t->ptses[0] &&
3503 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3504 sample_time = t->ptses[0];
3506 /* behave as if we have a proper index */
3507 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3509 /* get the stored order index from the display order index */
3510 sample_time += t->offsets[sample_time];
3512 /* no IndexEntryArray (one or more CBR segments)
3513 * make sure we don't seek past the end */
3514 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3517 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3520 ff_update_cur_dts(s, st, sample_time);
3521 mxf->current_edit_unit = sample_time;
3522 avio_seek(s->pb, seekpos, SEEK_SET);
3525 // Update all tracks sample count
3526 for (i = 0; i < s->nb_streams; i++) {
3527 AVStream *cur_st = s->streams[i];
3528 MXFTrack *cur_track = cur_st->priv_data;
3529 if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3530 int64_t track_edit_unit;
3531 if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
3532 cur_track->sample_count = av_rescale_q(track_edit_unit,
3533 av_inv_q(cur_track->edit_rate),
3536 uint64_t current_sample_count = 0;
3537 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3540 cur_track->sample_count = current_sample_count;
3547 AVInputFormat ff_mxf_demuxer = {
3549 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3550 .flags = AVFMT_SEEK_TO_PTS,
3551 .priv_data_size = sizeof(MXFContext),
3552 .read_probe = mxf_probe,
3553 .read_header = mxf_read_header,
3554 .read_packet = mxf_read_packet,
3555 .read_close = mxf_read_close,
3556 .read_seek = mxf_read_seek,