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
31 * SMPTE 2067-21 Interoperable Master Format — Application #2E
34 * Search for Track numbers which will identify essence element KLV packets.
35 * Search for SourcePackage which define tracks which contains Track numbers.
36 * Material Package contains tracks with reference to SourcePackage tracks.
37 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
38 * Assign Descriptors to correct Tracks.
40 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
41 * Metadata parsing resolves Strong References to objects.
43 * Simple demuxer, only OP1A supported and some files might not work at all.
44 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
49 #include "libavutil/aes.h"
50 #include "libavutil/avassert.h"
51 #include "libavutil/mastering_display_metadata.h"
52 #include "libavutil/mathematics.h"
53 #include "libavcodec/bytestream.h"
54 #include "libavutil/intreadwrite.h"
55 #include "libavutil/parseutils.h"
56 #include "libavutil/timecode.h"
57 #include "libavutil/opt.h"
62 #define MXF_MAX_CHUNK_SIZE (32 << 20)
81 OPSONYOpt, /* FATE sample, violates the spec in places */
90 typedef struct MXFPartition {
93 MXFPartitionType type;
94 uint64_t previous_partition;
97 int64_t this_partition;
98 int64_t essence_offset; ///< absolute offset of essence
99 int64_t essence_length;
101 int64_t header_byte_count;
102 int64_t index_byte_count;
104 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
106 KLVPacket first_essence_klv;
109 typedef struct MXFCryptoContext {
111 enum MXFMetadataSetType type;
112 UID source_container_ul;
115 typedef struct MXFStructuralComponent {
117 enum MXFMetadataSetType type;
118 UID source_package_ul;
119 UID source_package_uid;
120 UID data_definition_ul;
122 int64_t start_position;
124 } MXFStructuralComponent;
126 typedef struct MXFSequence {
128 enum MXFMetadataSetType type;
129 UID data_definition_ul;
130 UID *structural_components_refs;
131 int structural_components_count;
136 typedef struct MXFTimecodeComponent {
138 enum MXFMetadataSetType type;
141 struct AVRational rate;
143 } MXFTimecodeComponent;
147 enum MXFMetadataSetType type;
148 UID input_segment_ref;
149 } MXFPulldownComponent;
153 enum MXFMetadataSetType type;
154 UID *structural_components_refs;
155 int structural_components_count;
161 enum MXFMetadataSetType type;
168 enum MXFMetadataSetType type;
169 MXFSequence *sequence; /* mandatory, and only one */
173 uint8_t track_number[4];
174 AVRational edit_rate;
176 uint64_t sample_count;
177 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
180 MXFWrappingScheme wrapping;
181 int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
184 typedef struct MXFDescriptor {
186 enum MXFMetadataSetType type;
187 UID essence_container_ul;
188 UID essence_codec_ul;
190 AVRational sample_rate;
191 AVRational aspect_ratio;
193 int height; /* Field height, not frame height */
194 int frame_layout; /* See MXFFrameLayout enum */
195 int video_line_map[2];
196 #define MXF_FIELD_DOMINANCE_DEFAULT 0
197 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
198 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
202 int64_t duration; /* ContainerDuration optional property */
203 unsigned int component_depth;
204 unsigned int black_ref_level;
205 unsigned int white_ref_level;
206 unsigned int color_range;
207 unsigned int horiz_subsampling;
208 unsigned int vert_subsampling;
209 UID *sub_descriptors_refs;
210 int sub_descriptors_count;
214 enum AVPixelFormat pix_fmt;
215 UID color_primaries_ul;
218 AVMasteringDisplayMetadata *mastering;
219 AVContentLightMetadata *coll;
223 typedef struct MXFIndexTableSegment {
225 enum MXFMetadataSetType type;
226 int edit_unit_byte_count;
229 AVRational index_edit_rate;
230 uint64_t index_start_position;
231 uint64_t index_duration;
232 int8_t *temporal_offset_entries;
234 uint64_t *stream_offset_entries;
235 int nb_index_entries;
236 } MXFIndexTableSegment;
238 typedef struct MXFPackage {
240 enum MXFMetadataSetType type;
245 MXFDescriptor *descriptor; /* only one */
252 typedef struct MXFEssenceContainerData {
254 enum MXFMetadataSetType type;
259 } MXFEssenceContainerData;
261 typedef struct MXFMetadataSet {
263 enum MXFMetadataSetType type;
266 /* decoded index table */
267 typedef struct MXFIndexTable {
270 int nb_ptses; /* number of PTSes or total duration of index */
271 int64_t first_dts; /* DTS = EditUnit + first_dts */
272 int64_t *ptses; /* maps EditUnit -> PTS */
274 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
275 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
276 int8_t *offsets; /* temporal offsets for display order to stored order conversion */
279 typedef struct MXFContext {
280 const AVClass *class; /**< Class for private options. */
281 MXFPartition *partitions;
282 unsigned partitions_count;
286 UID *essence_container_data_refs;
287 int essence_container_data_count;
288 MXFMetadataSet **metadata_sets;
289 int metadata_sets_count;
293 int local_tags_count;
294 uint64_t footer_partition;
295 KLVPacket current_klv_data;
297 MXFPartition *current_partition;
298 int parsing_backward;
299 int64_t last_forward_tell;
300 int last_forward_partition;
302 MXFIndexTable *index_tables;
306 /* NOTE: klv_offset is not set (-1) for local keys */
307 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
309 typedef struct MXFMetadataReadTableEntry {
311 MXFMetadataReadFunc *read;
313 enum MXFMetadataSetType type;
314 } MXFMetadataReadTableEntry;
316 static int mxf_read_close(AVFormatContext *s);
318 /* partial keys to match */
319 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
320 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
321 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
322 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
323 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
324 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
325 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
326 static const uint8_t mxf_apple_coll_prefix[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01 };
327 /* complete keys to match */
328 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 };
329 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
330 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
331 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
332 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
333 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
334 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 };
335 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 };
336 static const uint8_t mxf_apple_coll_max_cll[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x01 };
337 static const uint8_t mxf_apple_coll_max_fall[] = { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0x0e,0x0e,0x20,0x04,0x01,0x05,0x03,0x01,0x02 };
339 static const uint8_t mxf_mastering_display_prefix[13] = { FF_MXF_MasteringDisplay_PREFIX };
340 static const uint8_t mxf_mastering_display_uls[4][16] = {
341 FF_MXF_MasteringDisplayPrimaries,
342 FF_MXF_MasteringDisplayWhitePointChromaticity,
343 FF_MXF_MasteringDisplayMaximumLuminance,
344 FF_MXF_MasteringDisplayMinimumLuminance,
347 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
349 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
351 MXFIndexTableSegment *seg;
352 switch ((*ctx)->type) {
354 case MultipleDescriptor:
355 av_freep(&((MXFDescriptor *)*ctx)->extradata);
356 av_freep(&((MXFDescriptor *)*ctx)->mastering);
357 av_freep(&((MXFDescriptor *)*ctx)->coll);
358 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
361 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
364 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
367 case MaterialPackage:
368 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
369 av_freep(&((MXFPackage *)*ctx)->name);
370 av_freep(&((MXFPackage *)*ctx)->comment_refs);
373 av_freep(&((MXFTaggedValue *)*ctx)->name);
374 av_freep(&((MXFTaggedValue *)*ctx)->value);
377 av_freep(&((MXFTrack *)*ctx)->name);
379 case IndexTableSegment:
380 seg = (MXFIndexTableSegment *)*ctx;
381 av_freep(&seg->temporal_offset_entries);
382 av_freep(&seg->flag_entries);
383 av_freep(&seg->stream_offset_entries);
392 static int64_t klv_decode_ber_length(AVIOContext *pb)
394 uint64_t size = avio_r8(pb);
395 if (size & 0x80) { /* long form */
396 int bytes_num = size & 0x7f;
397 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
399 return AVERROR_INVALIDDATA;
402 size = size << 8 | avio_r8(pb);
404 if (size > INT64_MAX)
405 return AVERROR_INVALIDDATA;
409 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
412 for (i = 0; i < size && !avio_feof(pb); i++) {
416 else if (b != key[i])
422 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
425 if (!mxf_read_sync(pb, mxf_klv_key, 4))
426 return AVERROR_INVALIDDATA;
427 klv->offset = avio_tell(pb) - 4;
428 memcpy(klv->key, mxf_klv_key, 4);
429 avio_read(pb, klv->key + 4, 12);
430 length = klv_decode_ber_length(pb);
433 klv->length = length;
435 if (pos > INT64_MAX - length)
436 return AVERROR_INVALIDDATA;
437 klv->next_klv = pos + length;
441 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv, int body_sid)
445 for (i = 0; i < s->nb_streams; i++) {
446 MXFTrack *track = s->streams[i]->priv_data;
448 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)))
451 /* return 0 if only one stream, for OP Atom files with 0 as track number */
452 return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
455 static int find_body_sid_by_absolute_offset(MXFContext *mxf, int64_t offset)
457 // we look for partition where the offset is placed
462 b = mxf->partitions_count;
466 pack_ofs = mxf->partitions[m].pack_ofs;
467 if (pack_ofs <= offset)
475 return mxf->partitions[a].body_sid;
478 static int mxf_get_eia608_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt, int64_t length)
480 int count = avio_rb16(s->pb);
481 int cdp_identifier, cdp_length, cdp_footer_id, ccdata_id, cc_count;
482 int line_num, sample_coding, sample_count;
483 int did, sdid, data_length;
487 av_log(s, AV_LOG_WARNING, "unsupported multiple ANC packets (%d) per KLV packet\n", count);
489 for (i = 0; i < count; i++) {
491 av_log(s, AV_LOG_ERROR, "error reading s436m packet %"PRId64"\n", length);
492 return AVERROR_INVALIDDATA;
494 line_num = avio_rb16(s->pb);
495 avio_r8(s->pb); // wrapping type
496 sample_coding = avio_r8(s->pb);
497 sample_count = avio_rb16(s->pb);
498 length -= 6 + 8 + sample_count;
499 if (line_num != 9 && line_num != 11)
501 if (sample_coding == 7 || sample_coding == 8 || sample_coding == 9) {
502 av_log(s, AV_LOG_WARNING, "unsupported s436m 10 bit sample coding\n");
506 return AVERROR_INVALIDDATA;
508 avio_rb32(s->pb); // array count
509 avio_rb32(s->pb); // array elem size
510 did = avio_r8(s->pb);
511 sdid = avio_r8(s->pb);
512 data_length = avio_r8(s->pb);
513 if (did != 0x61 || sdid != 1) {
514 av_log(s, AV_LOG_WARNING, "unsupported did or sdid: %x %x\n", did, sdid);
517 cdp_identifier = avio_rb16(s->pb); // cdp id
518 if (cdp_identifier != 0x9669) {
519 av_log(s, AV_LOG_ERROR, "wrong cdp identifier %x\n", cdp_identifier);
520 return AVERROR_INVALIDDATA;
522 cdp_length = avio_r8(s->pb);
523 avio_r8(s->pb); // cdp_frame_rate
524 avio_r8(s->pb); // cdp_flags
525 avio_rb16(s->pb); // cdp_hdr_sequence_cntr
526 ccdata_id = avio_r8(s->pb); // ccdata_id
527 if (ccdata_id != 0x72) {
528 av_log(s, AV_LOG_ERROR, "wrong cdp data section %x\n", ccdata_id);
529 return AVERROR_INVALIDDATA;
531 cc_count = avio_r8(s->pb) & 0x1f;
532 ret = av_get_packet(s->pb, pkt, cc_count * 3);
535 if (cdp_length - 9 - 4 < cc_count * 3) {
536 av_log(s, AV_LOG_ERROR, "wrong cdp size %d cc count %d\n", cdp_length, cc_count);
537 return AVERROR_INVALIDDATA;
539 avio_skip(s->pb, data_length - 9 - 4 - cc_count * 3);
540 cdp_footer_id = avio_r8(s->pb);
541 if (cdp_footer_id != 0x74) {
542 av_log(s, AV_LOG_ERROR, "wrong cdp footer section %x\n", cdp_footer_id);
543 return AVERROR_INVALIDDATA;
545 avio_rb16(s->pb); // cdp_ftr_sequence_cntr
546 avio_r8(s->pb); // packet_checksum
553 /* XXX: use AVBitStreamFilter */
554 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
556 const uint8_t *buf_ptr, *end_ptr;
560 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
561 return AVERROR_INVALIDDATA;
562 length = av_get_packet(pb, pkt, length);
565 data_ptr = pkt->data;
566 end_ptr = pkt->data + length;
567 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
568 for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
569 for (i = 0; i < st->codecpar->channels; i++) {
570 uint32_t sample = bytestream_get_le32(&buf_ptr);
571 if (st->codecpar->bits_per_coded_sample == 24)
572 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
574 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
576 buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
578 av_shrink_packet(pkt, data_ptr - pkt->data);
582 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
584 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
585 MXFContext *mxf = s->priv_data;
586 AVIOContext *pb = s->pb;
587 int64_t end = avio_tell(pb) + klv->length;
590 uint64_t plaintext_size;
596 if (!mxf->aesc && s->key && s->keylen == 16) {
597 mxf->aesc = av_aes_alloc();
599 return AVERROR(ENOMEM);
600 av_aes_init(mxf->aesc, s->key, 128, 1);
603 size = klv_decode_ber_length(pb);
608 klv_decode_ber_length(pb);
609 plaintext_size = avio_rb64(pb);
611 klv_decode_ber_length(pb);
612 avio_read(pb, klv->key, 16);
613 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
614 return AVERROR_INVALIDDATA;
616 body_sid = find_body_sid_by_absolute_offset(mxf, klv->offset);
617 index = mxf_get_stream_index(s, klv, body_sid);
619 return AVERROR_INVALIDDATA;
621 klv_decode_ber_length(pb);
622 orig_size = avio_rb64(pb);
623 if (orig_size < plaintext_size)
624 return AVERROR_INVALIDDATA;
626 size = klv_decode_ber_length(pb);
627 if (size < 32 || size - 32 < orig_size)
628 return AVERROR_INVALIDDATA;
629 avio_read(pb, ivec, 16);
630 avio_read(pb, tmpbuf, 16);
632 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
633 if (memcmp(tmpbuf, checkv, 16))
634 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
636 size = av_get_packet(pb, pkt, size);
639 else if (size < plaintext_size)
640 return AVERROR_INVALIDDATA;
641 size -= plaintext_size;
643 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
644 &pkt->data[plaintext_size], size >> 4, ivec, 1);
645 av_shrink_packet(pkt, orig_size);
646 pkt->stream_index = index;
647 avio_skip(pb, end - avio_tell(pb));
651 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
653 MXFContext *mxf = arg;
654 int item_num = avio_rb32(pb);
655 int item_len = avio_rb32(pb);
657 if (item_len != 18) {
658 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
659 return AVERROR_PATCHWELCOME;
661 if (item_num > 65536 || item_num < 0) {
662 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
663 return AVERROR_INVALIDDATA;
666 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
667 av_free(mxf->local_tags);
668 mxf->local_tags_count = 0;
669 mxf->local_tags = av_calloc(item_num, item_len);
670 if (!mxf->local_tags)
671 return AVERROR(ENOMEM);
672 mxf->local_tags_count = item_num;
673 avio_read(pb, mxf->local_tags, item_num*item_len);
677 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
679 MXFContext *mxf = arg;
680 AVFormatContext *s = mxf->fc;
681 MXFPartition *partition, *tmp_part;
683 uint64_t footer_partition;
684 uint32_t nb_essence_containers;
686 if (mxf->partitions_count >= INT_MAX / 2)
687 return AVERROR_INVALIDDATA;
689 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
691 return AVERROR(ENOMEM);
692 mxf->partitions = tmp_part;
694 if (mxf->parsing_backward) {
695 /* insert the new partition pack in the middle
696 * this makes the entries in mxf->partitions sorted by offset */
697 memmove(&mxf->partitions[mxf->last_forward_partition+1],
698 &mxf->partitions[mxf->last_forward_partition],
699 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
700 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
702 mxf->last_forward_partition++;
703 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
706 memset(partition, 0, sizeof(*partition));
707 mxf->partitions_count++;
708 partition->pack_length = avio_tell(pb) - klv_offset + size;
709 partition->pack_ofs = klv_offset;
713 partition->type = Header;
716 partition->type = BodyPartition;
719 partition->type = Footer;
722 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
723 return AVERROR_INVALIDDATA;
726 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
727 partition->closed = partition->type == Footer || !(uid[14] & 1);
728 partition->complete = uid[14] > 2;
730 partition->kag_size = avio_rb32(pb);
731 partition->this_partition = avio_rb64(pb);
732 partition->previous_partition = avio_rb64(pb);
733 footer_partition = avio_rb64(pb);
734 partition->header_byte_count = avio_rb64(pb);
735 partition->index_byte_count = avio_rb64(pb);
736 partition->index_sid = avio_rb32(pb);
737 partition->body_offset = avio_rb64(pb);
738 partition->body_sid = avio_rb32(pb);
739 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
740 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
741 return AVERROR_INVALIDDATA;
743 nb_essence_containers = avio_rb32(pb);
745 if (partition->type == Header) {
747 snprintf(str, sizeof(str), "%08x.%08x.%08x.%08x", AV_RB32(&op[0]), AV_RB32(&op[4]), AV_RB32(&op[8]), AV_RB32(&op[12]));
748 av_dict_set(&s->metadata, "operational_pattern_ul", str, 0);
751 if (partition->this_partition &&
752 partition->previous_partition == partition->this_partition) {
753 av_log(mxf->fc, AV_LOG_ERROR,
754 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
755 partition->previous_partition);
756 /* override with the actual previous partition offset */
757 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
759 mxf->partitions + mxf->last_forward_partition - 2;
760 partition->previous_partition = prev->this_partition;
762 /* if no previous body partition are found point to the header
764 if (partition->previous_partition == partition->this_partition)
765 partition->previous_partition = 0;
766 av_log(mxf->fc, AV_LOG_ERROR,
767 "Overriding PreviousPartition with %"PRIx64"\n",
768 partition->previous_partition);
771 /* some files don't have FooterPartition set in every partition */
772 if (footer_partition) {
773 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
774 av_log(mxf->fc, AV_LOG_ERROR,
775 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
776 mxf->footer_partition, footer_partition);
778 mxf->footer_partition = footer_partition;
782 av_log(mxf->fc, AV_LOG_TRACE,
783 "PartitionPack: ThisPartition = 0x%"PRIX64
784 ", PreviousPartition = 0x%"PRIX64", "
785 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
786 partition->this_partition,
787 partition->previous_partition, footer_partition,
788 partition->index_sid, partition->body_sid);
790 /* sanity check PreviousPartition if set */
791 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
792 if (partition->previous_partition &&
793 mxf->run_in + partition->previous_partition >= klv_offset) {
794 av_log(mxf->fc, AV_LOG_ERROR,
795 "PreviousPartition points to this partition or forward\n");
796 return AVERROR_INVALIDDATA;
799 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
800 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
801 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
802 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
803 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
804 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
805 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
806 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
807 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
808 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
809 else if (op[12] == 0x10) {
810 /* SMPTE 390m: "There shall be exactly one essence container"
811 * The following block deals with files that violate this, namely:
812 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
813 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
814 if (nb_essence_containers != 1) {
815 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
819 av_log(mxf->fc, AV_LOG_WARNING,
820 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
821 nb_essence_containers,
822 op == OP1a ? "OP1a" : "OPAtom");
828 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
832 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
833 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
834 partition->kag_size);
836 if (mxf->op == OPSONYOpt)
837 partition->kag_size = 512;
839 partition->kag_size = 1;
841 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
847 static int mxf_add_metadata_set(MXFContext *mxf, MXFMetadataSet **metadata_set)
849 MXFMetadataSet **tmp;
851 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
853 mxf_free_metadataset(metadata_set, 1);
854 return AVERROR(ENOMEM);
856 mxf->metadata_sets = tmp;
857 mxf->metadata_sets[mxf->metadata_sets_count] = *metadata_set;
858 mxf->metadata_sets_count++;
862 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
864 MXFCryptoContext *cryptocontext = arg;
866 return AVERROR_INVALIDDATA;
867 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
868 avio_read(pb, cryptocontext->source_container_ul, 16);
872 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
874 *count = avio_rb32(pb);
876 *refs = av_calloc(*count, sizeof(UID));
879 return AVERROR(ENOMEM);
881 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
882 avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
886 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
891 if (size < 0 || size > INT_MAX/2)
892 return AVERROR(EINVAL);
894 buf_size = size + size / 2 + 1;
896 *str = av_malloc(buf_size);
898 return AVERROR(ENOMEM);
901 ret = avio_get_str16be(pb, size, *str, buf_size);
903 ret = avio_get_str16le(pb, size, *str, buf_size);
913 #define READ_STR16(type, big_endian) \
914 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
916 return mxf_read_utf16_string(pb, size, str, big_endian); \
922 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
924 MXFContext *mxf = arg;
927 if (mxf->packages_refs)
928 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
929 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
931 return mxf_read_strong_ref_array(pb, &mxf->essence_container_data_refs, &mxf->essence_container_data_count);
936 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
938 MXFStructuralComponent *source_clip = arg;
941 source_clip->duration = avio_rb64(pb);
944 source_clip->start_position = avio_rb64(pb);
947 /* UMID, only get last 16 bytes */
948 avio_read(pb, source_clip->source_package_ul, 16);
949 avio_read(pb, source_clip->source_package_uid, 16);
952 source_clip->source_track_id = avio_rb32(pb);
958 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
960 MXFTimecodeComponent *mxf_timecode = arg;
963 mxf_timecode->start_frame = avio_rb64(pb);
966 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
969 mxf_timecode->drop_frame = avio_r8(pb);
975 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
977 MXFPulldownComponent *mxf_pulldown = arg;
980 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
986 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
988 MXFTrack *track = arg;
991 track->track_id = avio_rb32(pb);
994 avio_read(pb, track->track_number, 4);
997 mxf_read_utf16be_string(pb, size, &track->name);
1000 track->edit_rate.num = avio_rb32(pb);
1001 track->edit_rate.den = avio_rb32(pb);
1004 avio_read(pb, track->sequence_ref, 16);
1010 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1012 MXFSequence *sequence = arg;
1015 sequence->duration = avio_rb64(pb);
1018 avio_read(pb, sequence->data_definition_ul, 16);
1021 sequence->origin = avio_r8(pb);
1024 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
1025 &sequence->structural_components_count);
1030 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1032 MXFEssenceGroup *essence_group = arg;
1035 essence_group->duration = avio_rb64(pb);
1038 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
1039 &essence_group->structural_components_count);
1044 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1046 MXFPackage *package = arg;
1049 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
1050 &package->tracks_count);
1053 avio_read(pb, package->package_ul, 16);
1054 avio_read(pb, package->package_uid, 16);
1057 avio_read(pb, package->descriptor_ref, 16);
1060 return mxf_read_utf16be_string(pb, size, &package->name);
1062 return mxf_read_strong_ref_array(pb, &package->comment_refs,
1063 &package->comment_count);
1068 static int mxf_read_essence_container_data(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1070 MXFEssenceContainerData *essence_data = arg;
1073 /* linked package umid UMID */
1074 avio_read(pb, essence_data->package_ul, 16);
1075 avio_read(pb, essence_data->package_uid, 16);
1078 essence_data->index_sid = avio_rb32(pb);
1081 essence_data->body_sid = avio_rb32(pb);
1087 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
1091 segment->nb_index_entries = avio_rb32(pb);
1093 length = avio_rb32(pb);
1094 if(segment->nb_index_entries && length < 11)
1095 return AVERROR_INVALIDDATA;
1097 if (!FF_ALLOC_TYPED_ARRAY(segment->temporal_offset_entries, segment->nb_index_entries) ||
1098 !FF_ALLOC_TYPED_ARRAY(segment->flag_entries , segment->nb_index_entries) ||
1099 !FF_ALLOC_TYPED_ARRAY(segment->stream_offset_entries , segment->nb_index_entries)) {
1100 av_freep(&segment->temporal_offset_entries);
1101 av_freep(&segment->flag_entries);
1102 return AVERROR(ENOMEM);
1105 for (i = 0; i < segment->nb_index_entries; i++) {
1107 return AVERROR_INVALIDDATA;
1108 segment->temporal_offset_entries[i] = avio_r8(pb);
1109 avio_r8(pb); /* KeyFrameOffset */
1110 segment->flag_entries[i] = avio_r8(pb);
1111 segment->stream_offset_entries[i] = avio_rb64(pb);
1112 avio_skip(pb, length - 11);
1117 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1119 MXFIndexTableSegment *segment = arg;
1122 segment->edit_unit_byte_count = avio_rb32(pb);
1123 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
1126 segment->index_sid = avio_rb32(pb);
1127 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
1130 segment->body_sid = avio_rb32(pb);
1131 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
1134 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
1135 return mxf_read_index_entry_array(pb, segment);
1137 segment->index_edit_rate.num = avio_rb32(pb);
1138 segment->index_edit_rate.den = avio_rb32(pb);
1139 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
1140 segment->index_edit_rate.den);
1143 segment->index_start_position = avio_rb64(pb);
1144 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
1147 segment->index_duration = avio_rb64(pb);
1148 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
1154 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
1156 int code, value, ofs = 0;
1157 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
1161 value = avio_r8(pb);
1162 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
1165 layout[ofs++] = code;
1166 layout[ofs++] = value;
1168 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
1169 } while (code != 0); /* SMPTE 377M E.2.46 */
1171 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
1174 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1176 MXFDescriptor *descriptor = arg;
1177 int entry_count, entry_size;
1181 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
1182 &descriptor->sub_descriptors_count);
1183 case 0x3002: /* ContainerDuration */
1184 descriptor->duration = avio_rb64(pb);
1187 avio_read(pb, descriptor->essence_container_ul, 16);
1190 avio_read(pb, descriptor->codec_ul, 16);
1193 descriptor->linked_track_id = avio_rb32(pb);
1195 case 0x3201: /* PictureEssenceCoding */
1196 avio_read(pb, descriptor->essence_codec_ul, 16);
1199 descriptor->width = avio_rb32(pb);
1202 descriptor->height = avio_rb32(pb);
1205 descriptor->frame_layout = avio_r8(pb);
1208 entry_count = avio_rb32(pb);
1209 entry_size = avio_rb32(pb);
1210 if (entry_size == 4) {
1211 if (entry_count > 0)
1212 descriptor->video_line_map[0] = avio_rb32(pb);
1214 descriptor->video_line_map[0] = 0;
1215 if (entry_count > 1)
1216 descriptor->video_line_map[1] = avio_rb32(pb);
1218 descriptor->video_line_map[1] = 0;
1220 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1223 descriptor->aspect_ratio.num = avio_rb32(pb);
1224 descriptor->aspect_ratio.den = avio_rb32(pb);
1227 avio_read(pb, descriptor->color_trc_ul, 16);
1230 descriptor->field_dominance = avio_r8(pb);
1233 avio_read(pb, descriptor->color_primaries_ul, 16);
1236 avio_read(pb, descriptor->color_space_ul, 16);
1239 descriptor->component_depth = avio_rb32(pb);
1242 descriptor->horiz_subsampling = avio_rb32(pb);
1245 descriptor->black_ref_level = avio_rb32(pb);
1248 descriptor->white_ref_level = avio_rb32(pb);
1251 descriptor->color_range = avio_rb32(pb);
1254 descriptor->vert_subsampling = avio_rb32(pb);
1257 descriptor->sample_rate.num = avio_rb32(pb);
1258 descriptor->sample_rate.den = avio_rb32(pb);
1260 case 0x3D06: /* SoundEssenceCompression */
1261 avio_read(pb, descriptor->essence_codec_ul, 16);
1264 descriptor->channels = avio_rb32(pb);
1267 descriptor->bits_per_sample = avio_rb32(pb);
1270 mxf_read_pixel_layout(pb, descriptor);
1273 /* Private uid used by SONY C0023S01.mxf */
1274 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1275 if (descriptor->extradata)
1276 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1277 av_free(descriptor->extradata);
1278 descriptor->extradata_size = 0;
1279 descriptor->extradata = av_malloc(size);
1280 if (!descriptor->extradata)
1281 return AVERROR(ENOMEM);
1282 descriptor->extradata_size = size;
1283 avio_read(pb, descriptor->extradata, size);
1285 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1286 uint32_t rsiz = avio_rb16(pb);
1287 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1288 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1289 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1291 if (IS_KLV_KEY(uid, mxf_mastering_display_prefix)) {
1292 if (!descriptor->mastering) {
1293 descriptor->mastering = av_mastering_display_metadata_alloc();
1294 if (!descriptor->mastering)
1295 return AVERROR(ENOMEM);
1297 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[0])) {
1298 for (int i = 0; i < 3; i++) {
1299 /* Order: large x, large y, other (i.e. RGB) */
1300 descriptor->mastering->display_primaries[i][0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1301 descriptor->mastering->display_primaries[i][1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1303 /* Check we have seen mxf_mastering_display_white_point_chromaticity */
1304 if (descriptor->mastering->white_point[0].den != 0)
1305 descriptor->mastering->has_primaries = 1;
1307 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[1])) {
1308 descriptor->mastering->white_point[0] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1309 descriptor->mastering->white_point[1] = av_make_q(avio_rb16(pb), FF_MXF_MASTERING_CHROMA_DEN);
1310 /* Check we have seen mxf_mastering_display_primaries */
1311 if (descriptor->mastering->display_primaries[0][0].den != 0)
1312 descriptor->mastering->has_primaries = 1;
1314 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[2])) {
1315 descriptor->mastering->max_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1316 /* Check we have seen mxf_mastering_display_minimum_luminance */
1317 if (descriptor->mastering->min_luminance.den != 0)
1318 descriptor->mastering->has_luminance = 1;
1320 if (IS_KLV_KEY(uid, mxf_mastering_display_uls[3])) {
1321 descriptor->mastering->min_luminance = av_make_q(avio_rb32(pb), FF_MXF_MASTERING_LUMA_DEN);
1322 /* Check we have seen mxf_mastering_display_maximum_luminance */
1323 if (descriptor->mastering->max_luminance.den != 0)
1324 descriptor->mastering->has_luminance = 1;
1327 if (IS_KLV_KEY(uid, mxf_apple_coll_prefix)) {
1328 if (!descriptor->coll) {
1329 descriptor->coll = av_content_light_metadata_alloc(&descriptor->coll_size);
1330 if (!descriptor->coll)
1331 return AVERROR(ENOMEM);
1333 if (IS_KLV_KEY(uid, mxf_apple_coll_max_cll)) {
1334 descriptor->coll->MaxCLL = avio_rb16(pb);
1336 if (IS_KLV_KEY(uid, mxf_apple_coll_max_fall)) {
1337 descriptor->coll->MaxFALL = avio_rb16(pb);
1345 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1347 MXFTaggedValue *tagged_value = arg;
1353 avio_read(pb, key, 17);
1354 /* TODO: handle other types of of indirect values */
1355 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1356 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1357 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1358 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1363 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1365 MXFTaggedValue *tagged_value = arg;
1368 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1370 return mxf_read_indirect_value(tagged_value, pb, size);
1376 * Match an uid independently of the version byte and up to len common bytes
1379 static int mxf_match_uid(const UID key, const UID uid, int len)
1382 for (i = 0; i < len; i++) {
1383 if (i != 7 && key[i] != uid[i])
1389 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1391 while (uls->uid[0]) {
1392 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1399 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1405 for (i = 0; i < mxf->metadata_sets_count; i++) {
1406 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1407 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1408 return mxf->metadata_sets[i];
1414 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1415 // video essence container uls
1416 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000, NULL, 14 },
1417 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264, NULL, 15 }, /* H.264 */
1418 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x11,0x01,0x00 }, 14, AV_CODEC_ID_DNXHD, NULL, 14 }, /* VC-3 */
1419 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1, NULL, 14 }, /* VC-1 */
1420 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x14,0x01,0x00 }, 14, AV_CODEC_ID_TIFF, NULL, 14 }, /* TIFF */
1421 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x15,0x01,0x00 }, 14, AV_CODEC_ID_DIRAC, NULL, 14 }, /* VC-2 */
1422 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1b,0x01,0x00 }, 14, AV_CODEC_ID_CFHD, NULL, 14 }, /* VC-5 */
1423 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x1c,0x01,0x00 }, 14, AV_CODEC_ID_PRORES, NULL, 14 }, /* ProRes */
1424 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15 }, /* MPEG-ES */
1425 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO, NULL, 15, D10D11Wrap }, /* SMPTE D-10 mapping */
1426 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO, NULL, 15 }, /* DV 625 25mbps */
1427 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO, NULL, 15, RawVWrap }, /* uncompressed picture */
1428 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1429 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1430 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x15,0x00,0x04,0x02,0x10,0x00,0x01 }, 16, AV_CODEC_ID_HEVC, NULL, 15 }, /* Canon XF-HEVC */
1431 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1432 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1435 /* EC ULs for intra-only formats */
1436 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1437 { { 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 */
1438 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1441 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1442 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1443 { { 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 */
1444 { { 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 */
1445 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1448 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1449 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1450 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1451 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1452 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1453 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1454 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1457 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1458 // sound essence container uls
1459 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 14, RawAWrap }, /* BWF */
1460 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2, NULL, 15 }, /* MPEG-ES */
1461 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE, NULL, 13 }, /* D-10 Mapping 50Mbps PAL Extended Template */
1462 { { 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 */
1463 { { 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) */
1464 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1467 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1468 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0d,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_smpte_436M", 11 },
1469 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE, "vbi_vanc_smpte_436M", 11 },
1470 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x13,0x01,0x01 }, 16, AV_CODEC_ID_TTML },
1471 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1474 static MXFWrappingScheme mxf_get_wrapping_kind(UID *essence_container_ul)
1477 const MXFCodecUL *codec_ul;
1479 codec_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1480 if (!codec_ul->uid[0])
1481 codec_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1482 if (!codec_ul->uid[0])
1483 codec_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
1484 if (!codec_ul->uid[0] || !codec_ul->wrapping_indicator_pos)
1485 return UnknownWrapped;
1487 val = (*essence_container_ul)[codec_ul->wrapping_indicator_pos];
1488 switch (codec_ul->wrapping_indicator_type) {
1493 if (val == 0x03 || val == 0x04)
1502 return FrameWrapped;
1505 return UnknownWrapped;
1508 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1510 int i, j, nb_segments = 0;
1511 MXFIndexTableSegment **unsorted_segments;
1512 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1514 /* count number of segments, allocate arrays and copy unsorted segments */
1515 for (i = 0; i < mxf->metadata_sets_count; i++)
1516 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1520 return AVERROR_INVALIDDATA;
1522 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1523 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1524 av_freep(sorted_segments);
1525 av_free(unsorted_segments);
1526 return AVERROR(ENOMEM);
1529 for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
1530 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
1531 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1532 if (s->edit_unit_byte_count || s->nb_index_entries)
1533 unsorted_segments[nb_segments++] = s;
1535 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1536 s->index_sid, s->index_start_position);
1541 av_freep(sorted_segments);
1542 av_free(unsorted_segments);
1543 return AVERROR_INVALIDDATA;
1546 *nb_sorted_segments = 0;
1548 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1549 for (i = 0; i < nb_segments; i++) {
1550 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1551 uint64_t best_index_duration = 0;
1553 for (j = 0; j < nb_segments; j++) {
1554 MXFIndexTableSegment *s = unsorted_segments[j];
1556 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1557 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1558 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1561 s->body_sid > last_body_sid ||
1562 s->body_sid == last_body_sid && s->index_sid > last_index_sid ||
1563 s->body_sid == last_body_sid && s->index_sid == last_index_sid && s->index_start_position > last_index_start) &&
1565 s->body_sid < best_body_sid ||
1566 s->body_sid == best_body_sid && s->index_sid < best_index_sid ||
1567 s->body_sid == best_body_sid && s->index_sid == best_index_sid && s->index_start_position < best_index_start ||
1568 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)) {
1570 best_body_sid = s->body_sid;
1571 best_index_sid = s->index_sid;
1572 best_index_start = s->index_start_position;
1573 best_index_duration = s->index_duration;
1577 /* no suitable entry found -> we're done */
1581 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1582 last_body_sid = best_body_sid;
1583 last_index_sid = best_index_sid;
1584 last_index_start = best_index_start;
1587 av_free(unsorted_segments);
1593 * Computes the absolute file offset of the given essence container offset
1595 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
1597 MXFPartition *last_p = NULL;
1601 return AVERROR(EINVAL);
1604 b = mxf->partitions_count;
1607 m0 = m = (a + b) >> 1;
1609 while (m < b && mxf->partitions[m].body_sid != body_sid)
1612 if (m < b && mxf->partitions[m].body_offset <= offset)
1619 last_p = &mxf->partitions[a];
1621 if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
1622 *offset_out = last_p->essence_offset + (offset - last_p->body_offset);
1624 *partition_out = last_p;
1628 av_log(mxf->fc, AV_LOG_ERROR,
1629 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1632 return AVERROR_INVALIDDATA;
1636 * Returns the end position of the essence container with given BodySID, or zero if unknown
1638 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1640 for (int x = mxf->partitions_count - 1; x >= 0; x--) {
1641 MXFPartition *p = &mxf->partitions[x];
1643 if (p->body_sid != body_sid)
1646 if (!p->essence_length)
1649 return p->essence_offset + p->essence_length;
1655 /* EditUnit -> absolute offset */
1656 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
1659 int64_t offset_temp = 0;
1661 edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
1663 for (i = 0; i < index_table->nb_segments; i++) {
1664 MXFIndexTableSegment *s = index_table->segments[i];
1666 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1668 if (edit_unit < s->index_start_position + s->index_duration) {
1669 int64_t index = edit_unit - s->index_start_position;
1671 if (s->edit_unit_byte_count)
1672 offset_temp += s->edit_unit_byte_count * index;
1674 if (s->nb_index_entries == 2 * s->index_duration + 1)
1675 index *= 2; /* Avid index */
1677 if (index < 0 || index >= s->nb_index_entries) {
1678 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1679 index_table->index_sid, s->index_start_position);
1680 return AVERROR_INVALIDDATA;
1683 offset_temp = s->stream_offset_entries[index];
1687 *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
1689 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_out);
1691 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1692 offset_temp += s->edit_unit_byte_count * s->index_duration;
1697 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);
1699 return AVERROR_INVALIDDATA;
1702 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1705 int8_t max_temporal_offset = -128;
1708 /* first compute how many entries we have */
1709 for (i = 0; i < index_table->nb_segments; i++) {
1710 MXFIndexTableSegment *s = index_table->segments[i];
1712 if (!s->nb_index_entries) {
1713 index_table->nb_ptses = 0;
1714 return 0; /* no TemporalOffsets */
1717 if (s->index_duration > INT_MAX - index_table->nb_ptses) {
1718 index_table->nb_ptses = 0;
1719 av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
1723 index_table->nb_ptses += s->index_duration;
1726 /* paranoid check */
1727 if (index_table->nb_ptses <= 0)
1730 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1731 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1732 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1733 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1734 av_freep(&index_table->ptses);
1735 av_freep(&index_table->fake_index);
1736 av_freep(&index_table->offsets);
1737 return AVERROR(ENOMEM);
1740 /* we may have a few bad TemporalOffsets
1741 * make sure the corresponding PTSes don't have the bogus value 0 */
1742 for (x = 0; x < index_table->nb_ptses; x++)
1743 index_table->ptses[x] = AV_NOPTS_VALUE;
1757 * We want to transform it into this:
1768 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1769 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1770 * The latter makes DTS <= PTS.
1772 for (i = x = 0; i < index_table->nb_segments; i++) {
1773 MXFIndexTableSegment *s = index_table->segments[i];
1774 int index_delta = 1;
1775 int n = s->nb_index_entries;
1777 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1778 index_delta = 2; /* Avid index */
1779 /* ignore the last entry - it's the size of the essence container */
1783 for (j = 0; j < n; j += index_delta, x++) {
1784 int offset = s->temporal_offset_entries[j] / index_delta;
1785 int index = x + offset;
1787 if (x >= index_table->nb_ptses) {
1788 av_log(mxf->fc, AV_LOG_ERROR,
1789 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1790 s->nb_index_entries, s->index_duration);
1794 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1796 if (index < 0 || index >= index_table->nb_ptses) {
1797 av_log(mxf->fc, AV_LOG_ERROR,
1798 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1803 index_table->offsets[x] = offset;
1804 index_table->ptses[index] = x;
1805 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1809 /* calculate the fake index table in display order */
1810 for (x = 0; x < index_table->nb_ptses; x++) {
1811 index_table->fake_index[x].timestamp = x;
1812 if (index_table->ptses[x] != AV_NOPTS_VALUE)
1813 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1817 index_table->first_dts = -max_temporal_offset;
1823 * Sorts and collects index table segments into index tables.
1824 * Also computes PTSes if possible.
1826 static int mxf_compute_index_tables(MXFContext *mxf)
1828 int i, j, k, ret, nb_sorted_segments;
1829 MXFIndexTableSegment **sorted_segments = NULL;
1831 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1832 nb_sorted_segments <= 0) {
1833 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1837 /* sanity check and count unique BodySIDs/IndexSIDs */
1838 for (i = 0; i < nb_sorted_segments; i++) {
1839 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1840 mxf->nb_index_tables++;
1841 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1842 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1843 ret = AVERROR_INVALIDDATA;
1844 goto finish_decoding_index;
1848 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1849 sizeof(*mxf->index_tables));
1850 if (!mxf->index_tables) {
1851 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1852 ret = AVERROR(ENOMEM);
1853 goto finish_decoding_index;
1856 /* distribute sorted segments to index tables */
1857 for (i = j = 0; i < nb_sorted_segments; i++) {
1858 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1863 mxf->index_tables[j].nb_segments++;
1866 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1867 MXFIndexTable *t = &mxf->index_tables[j];
1868 MXFTrack *mxf_track = NULL;
1870 t->segments = av_mallocz_array(t->nb_segments,
1871 sizeof(*t->segments));
1874 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1875 " pointer array\n");
1876 ret = AVERROR(ENOMEM);
1877 goto finish_decoding_index;
1880 if (sorted_segments[i]->index_start_position)
1881 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1882 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1884 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1885 t->index_sid = sorted_segments[i]->index_sid;
1886 t->body_sid = sorted_segments[i]->body_sid;
1888 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1889 goto finish_decoding_index;
1891 for (k = 0; k < mxf->fc->nb_streams; k++) {
1892 MXFTrack *track = mxf->fc->streams[k]->priv_data;
1893 if (track && track->index_sid == t->index_sid) {
1899 /* fix zero IndexDurations */
1900 for (k = 0; k < t->nb_segments; k++) {
1901 if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
1902 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
1905 t->segments[k]->index_edit_rate = mxf_track->edit_rate;
1908 if (t->segments[k]->index_duration)
1911 if (t->nb_segments > 1)
1912 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1916 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1920 /* assume the first stream's duration is reasonable
1921 * leave index_duration = 0 on further segments in case we have any (unlikely)
1923 t->segments[k]->index_duration = mxf_track->original_duration;
1929 finish_decoding_index:
1930 av_free(sorted_segments);
1934 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1936 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1937 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1938 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1939 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1942 static int mxf_uid_to_str(UID uid, char **str)
1946 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1948 return AVERROR(ENOMEM);
1949 for (i = 0; i < sizeof(UID); i++) {
1950 snprintf(p, 2 + 1, "%.2x", uid[i]);
1952 if (i == 3 || i == 5 || i == 7 || i == 9) {
1953 snprintf(p, 1 + 1, "-");
1960 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1964 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1966 return AVERROR(ENOMEM);
1967 snprintf(p, 2 + 1, "0x");
1969 for (i = 0; i < sizeof(UID); i++) {
1970 snprintf(p, 2 + 1, "%.2X", ul[i]);
1974 for (i = 0; i < sizeof(UID); i++) {
1975 snprintf(p, 2 + 1, "%.2X", uid[i]);
1981 static int mxf_version_to_str(uint16_t major, uint16_t minor, uint16_t tertiary,
1982 uint16_t patch, uint16_t release, char **str)
1984 *str = av_asprintf("%d.%d.%d.%d.%d", major, minor, tertiary, patch, release);
1986 return AVERROR(ENOMEM);
1990 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1996 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1998 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
2002 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
2004 char buf[AV_TIMECODE_STR_SIZE];
2005 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
2010 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
2012 MXFStructuralComponent *component = NULL;
2013 MXFPulldownComponent *pulldown = NULL;
2015 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2019 switch (component->type) {
2020 case TimecodeComponent:
2021 return (MXFTimecodeComponent*)component;
2022 case PulldownComponent: /* timcode component may be located on a pulldown component */
2023 pulldown = (MXFPulldownComponent*)component;
2024 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
2031 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
2033 MXFPackage *package = NULL;
2036 for (i = 0; i < mxf->packages_count; i++) {
2037 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
2041 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
2047 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
2049 MXFDescriptor *sub_descriptor = NULL;
2055 if (descriptor->type == MultipleDescriptor) {
2056 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
2057 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
2059 if (!sub_descriptor) {
2060 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
2063 if (sub_descriptor->linked_track_id == track_id) {
2064 return sub_descriptor;
2067 } else if (descriptor->type == Descriptor)
2073 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
2075 MXFStructuralComponent *component = NULL;
2076 MXFPackage *package = NULL;
2077 MXFDescriptor *descriptor = NULL;
2080 if (!essence_group || !essence_group->structural_components_count)
2083 /* essence groups contains multiple representations of the same media,
2084 this return the first components with a valid Descriptor typically index 0 */
2085 for (i =0; i < essence_group->structural_components_count; i++){
2086 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
2090 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
2093 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
2100 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
2102 MXFStructuralComponent *component = NULL;
2104 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
2107 switch (component->type) {
2111 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
2118 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
2120 MXFTaggedValue *tag;
2124 for (i = 0; i < package->comment_count; i++) {
2125 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
2126 if (!tag || !tag->name || !tag->value)
2129 key = av_asprintf("comment_%s", tag->name);
2131 return AVERROR(ENOMEM);
2133 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
2138 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
2140 MXFPackage *physical_package = NULL;
2141 MXFTrack *physical_track = NULL;
2142 MXFStructuralComponent *sourceclip = NULL;
2143 MXFTimecodeComponent *mxf_tc = NULL;
2147 int64_t start_position;
2149 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
2150 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
2154 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
2157 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
2159 /* the name of physical source package is name of the reel or tape */
2160 if (physical_package->name && physical_package->name[0])
2161 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
2163 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
2164 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
2166 for (j = 0; j < physical_package->tracks_count; j++) {
2167 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
2168 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2172 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
2173 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2177 if (physical_track->edit_rate.num <= 0 ||
2178 physical_track->edit_rate.den <= 0) {
2179 av_log(mxf->fc, AV_LOG_WARNING,
2180 "Invalid edit rate (%d/%d) found on structural"
2181 " component #%d, defaulting to 25/1\n",
2182 physical_track->edit_rate.num,
2183 physical_track->edit_rate.den, i);
2184 physical_track->edit_rate = (AVRational){25, 1};
2187 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
2188 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
2191 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2192 /* scale sourceclip start_position to match physical track edit rate */
2193 start_position = av_rescale_q(sourceclip->start_position,
2194 physical_track->edit_rate,
2195 source_track->edit_rate);
2197 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
2198 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
2208 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
2210 MXFStructuralComponent *component = NULL;
2211 const MXFCodecUL *codec_ul = NULL;
2212 MXFPackage tmp_package;
2216 for (j = 0; j < track->sequence->structural_components_count; j++) {
2217 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
2225 st = avformat_new_stream(mxf->fc, NULL);
2227 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
2228 return AVERROR(ENOMEM);
2231 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
2232 st->codecpar->codec_id = AV_CODEC_ID_NONE;
2233 st->id = track->track_id;
2235 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
2236 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
2237 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
2238 if (track->name && track->name[0])
2239 av_dict_set(&st->metadata, "track_name", track->name, 0);
2241 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
2242 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
2246 static enum AVColorRange mxf_get_color_range(MXFContext *mxf, MXFDescriptor *descriptor)
2248 if (descriptor->black_ref_level || descriptor->white_ref_level || descriptor->color_range) {
2249 /* CDCI range metadata */
2250 if (!descriptor->component_depth)
2251 return AVCOL_RANGE_UNSPECIFIED;
2252 if (descriptor->black_ref_level == 0 &&
2253 descriptor->white_ref_level == ((1<<descriptor->component_depth) - 1) &&
2254 (descriptor->color_range == (1<<descriptor->component_depth) ||
2255 descriptor->color_range == ((1<<descriptor->component_depth) - 1)))
2256 return AVCOL_RANGE_JPEG;
2257 if (descriptor->component_depth >= 8 &&
2258 descriptor->black_ref_level == (1 <<(descriptor->component_depth - 4)) &&
2259 descriptor->white_ref_level == (235<<(descriptor->component_depth - 8)) &&
2260 descriptor->color_range == ((14<<(descriptor->component_depth - 4)) + 1))
2261 return AVCOL_RANGE_MPEG;
2262 avpriv_request_sample(mxf->fc, "Unrecognized CDCI color range (color diff range %d, b %d, w %d, depth %d)",
2263 descriptor->color_range, descriptor->black_ref_level,
2264 descriptor->white_ref_level, descriptor->component_depth);
2267 return AVCOL_RANGE_UNSPECIFIED;
2270 static int mxf_parse_structural_metadata(MXFContext *mxf)
2272 MXFPackage *material_package = NULL;
2275 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
2276 /* TODO: handle multiple material packages (OP3x) */
2277 for (i = 0; i < mxf->packages_count; i++) {
2278 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
2279 if (material_package) break;
2281 if (!material_package) {
2282 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
2283 return AVERROR_INVALIDDATA;
2286 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
2287 if (material_package->name && material_package->name[0])
2288 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
2289 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
2291 for (i = 0; i < material_package->tracks_count; i++) {
2292 MXFPackage *source_package = NULL;
2293 MXFTrack *material_track = NULL;
2294 MXFTrack *source_track = NULL;
2295 MXFTrack *temp_track = NULL;
2296 MXFDescriptor *descriptor = NULL;
2297 MXFStructuralComponent *component = NULL;
2298 MXFTimecodeComponent *mxf_tc = NULL;
2299 UID *essence_container_ul = NULL;
2300 const MXFCodecUL *codec_ul = NULL;
2301 const MXFCodecUL *container_ul = NULL;
2302 const MXFCodecUL *pix_fmt_ul = NULL;
2307 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
2308 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
2312 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
2313 mxf_tc = (MXFTimecodeComponent*)component;
2314 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2315 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2316 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2320 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
2321 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
2325 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2326 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
2330 mxf_tc = (MXFTimecodeComponent*)component;
2331 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
2332 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
2333 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
2338 /* TODO: handle multiple source clips, only finds first valid source clip */
2339 if(material_track->sequence->structural_components_count > 1)
2340 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
2341 material_track->track_id, material_track->sequence->structural_components_count);
2343 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
2344 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
2348 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
2349 if (!source_package) {
2350 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
2353 for (k = 0; k < source_package->tracks_count; k++) {
2354 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
2355 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
2356 ret = AVERROR_INVALIDDATA;
2359 if (temp_track->track_id == component->source_track_id) {
2360 source_track = temp_track;
2364 if (!source_track) {
2365 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
2369 for (k = 0; k < mxf->essence_container_data_count; k++) {
2370 MXFEssenceContainerData *essence_data;
2372 if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
2373 av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
2376 if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
2377 source_track->body_sid = essence_data->body_sid;
2378 source_track->index_sid = essence_data->index_sid;
2383 if(source_track && component)
2386 if (!source_track || !component || !source_package) {
2387 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2392 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2393 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2394 ret = AVERROR_INVALIDDATA;
2398 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2399 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2400 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2401 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2405 st = avformat_new_stream(mxf->fc, NULL);
2407 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2408 ret = AVERROR(ENOMEM);
2411 st->id = material_track->track_id;
2412 st->priv_data = source_track;
2414 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2415 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2417 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2418 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2419 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2420 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2422 source_track->original_duration = st->duration = component->duration;
2424 if (st->duration == -1)
2425 st->duration = AV_NOPTS_VALUE;
2426 st->start_time = component->start_position;
2427 if (material_track->edit_rate.num <= 0 ||
2428 material_track->edit_rate.den <= 0) {
2429 av_log(mxf->fc, AV_LOG_WARNING,
2430 "Invalid edit rate (%d/%d) found on stream #%d, "
2431 "defaulting to 25/1\n",
2432 material_track->edit_rate.num,
2433 material_track->edit_rate.den, st->index);
2434 material_track->edit_rate = (AVRational){25, 1};
2436 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2438 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2439 * the former is accessible via st->priv_data */
2440 source_track->edit_rate = material_track->edit_rate;
2442 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2443 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2444 st->codecpar->codec_type = codec_ul->id;
2447 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2450 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2451 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2452 essence_container_ul = &descriptor->essence_container_ul;
2453 source_track->wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_kind(essence_container_ul);
2454 if (source_track->wrapping == UnknownWrapped)
2455 av_log(mxf->fc, AV_LOG_INFO, "wrapping of stream %d is unknown\n", st->index);
2456 /* HACK: replacing the original key with mxf_encrypted_essence_container
2457 * is not allowed according to s429-6, try to find correct information anyway */
2458 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2459 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2460 for (k = 0; k < mxf->metadata_sets_count; k++) {
2461 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2462 if (metadata->type == CryptoContext) {
2463 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2469 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2470 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2471 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2472 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2473 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2474 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2477 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2478 avcodec_get_name(st->codecpar->codec_id));
2479 for (k = 0; k < 16; k++) {
2480 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2481 descriptor->essence_codec_ul[k]);
2482 if (!(k+1 & 19) || k == 5)
2483 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2485 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2487 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2488 if (source_package->name && source_package->name[0])
2489 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2490 if (material_track->name && material_track->name[0])
2491 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2493 mxf_parse_physical_source_package(mxf, source_track, st);
2495 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2496 source_track->intra_only = mxf_is_intra_only(descriptor);
2497 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2498 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2499 st->codecpar->codec_id = container_ul->id;
2500 st->codecpar->width = descriptor->width;
2501 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2502 switch (descriptor->frame_layout) {
2504 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2507 /* Every other line is stored and needs to be duplicated. */
2508 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2509 break; /* The correct thing to do here is fall through, but by breaking we might be
2510 able to decode some streams at half the vertical resolution, rather than not al all.
2511 It's also for compatibility with the old behavior. */
2514 case SegmentedFrame:
2515 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2516 case SeparateFields:
2517 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2518 descriptor->video_line_map[0], descriptor->video_line_map[1],
2519 descriptor->field_dominance);
2520 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2521 /* Detect coded field order from VideoLineMap:
2522 * (even, even) => bottom field coded first
2523 * (even, odd) => top field coded first
2524 * (odd, even) => top field coded first
2525 * (odd, odd) => bottom field coded first
2527 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2528 switch (descriptor->field_dominance) {
2529 case MXF_FIELD_DOMINANCE_DEFAULT:
2530 case MXF_FIELD_DOMINANCE_FF:
2531 st->codecpar->field_order = AV_FIELD_TT;
2533 case MXF_FIELD_DOMINANCE_FL:
2534 st->codecpar->field_order = AV_FIELD_TB;
2537 avpriv_request_sample(mxf->fc,
2538 "Field dominance %d support",
2539 descriptor->field_dominance);
2542 switch (descriptor->field_dominance) {
2543 case MXF_FIELD_DOMINANCE_DEFAULT:
2544 case MXF_FIELD_DOMINANCE_FF:
2545 st->codecpar->field_order = AV_FIELD_BB;
2547 case MXF_FIELD_DOMINANCE_FL:
2548 st->codecpar->field_order = AV_FIELD_BT;
2551 avpriv_request_sample(mxf->fc,
2552 "Field dominance %d support",
2553 descriptor->field_dominance);
2557 /* Turn field height into frame height. */
2558 st->codecpar->height *= 2;
2561 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2564 if (st->codecpar->codec_id == AV_CODEC_ID_PRORES) {
2565 switch (descriptor->essence_codec_ul[14]) {
2566 case 1: st->codecpar->codec_tag = MKTAG('a','p','c','o'); break;
2567 case 2: st->codecpar->codec_tag = MKTAG('a','p','c','s'); break;
2568 case 3: st->codecpar->codec_tag = MKTAG('a','p','c','n'); break;
2569 case 4: st->codecpar->codec_tag = MKTAG('a','p','c','h'); break;
2570 case 5: st->codecpar->codec_tag = MKTAG('a','p','4','h'); break;
2571 case 6: st->codecpar->codec_tag = MKTAG('a','p','4','x'); break;
2575 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2576 st->codecpar->format = descriptor->pix_fmt;
2577 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2578 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2579 &descriptor->essence_codec_ul);
2580 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2581 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2582 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2583 &descriptor->essence_codec_ul)->id;
2584 if (!st->codecpar->codec_tag) {
2585 /* support files created before RP224v10 by defaulting to UYVY422
2586 if subsampling is 4:2:2 and component depth is 8-bit */
2587 if (descriptor->horiz_subsampling == 2 &&
2588 descriptor->vert_subsampling == 1 &&
2589 descriptor->component_depth == 8) {
2590 st->codecpar->format = AV_PIX_FMT_UYVY422;
2596 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2597 if (material_track->sequence->origin) {
2598 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2600 if (source_track->sequence->origin) {
2601 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2603 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2604 st->internal->display_aspect_ratio = descriptor->aspect_ratio;
2605 st->codecpar->color_range = mxf_get_color_range(mxf, descriptor);
2606 st->codecpar->color_primaries = mxf_get_codec_ul(ff_mxf_color_primaries_uls, &descriptor->color_primaries_ul)->id;
2607 st->codecpar->color_trc = mxf_get_codec_ul(ff_mxf_color_trc_uls, &descriptor->color_trc_ul)->id;
2608 st->codecpar->color_space = mxf_get_codec_ul(ff_mxf_color_space_uls, &descriptor->color_space_ul)->id;
2609 if (descriptor->mastering) {
2610 ret = av_stream_add_side_data(st, AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
2611 (uint8_t *)descriptor->mastering,
2612 sizeof(*descriptor->mastering));
2615 descriptor->mastering = NULL;
2617 if (descriptor->coll) {
2618 ret = av_stream_add_side_data(st, AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
2619 (uint8_t *)descriptor->coll,
2620 descriptor->coll_size);
2623 descriptor->coll = NULL;
2625 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2626 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2627 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2628 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))
2629 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2630 st->codecpar->channels = descriptor->channels;
2632 if (descriptor->sample_rate.den > 0) {
2633 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2634 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2636 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2637 "found for stream #%d, time base forced to 1/48000\n",
2638 descriptor->sample_rate.num, descriptor->sample_rate.den,
2640 avpriv_set_pts_info(st, 64, 1, 48000);
2643 /* if duration is set, rescale it from EditRate to SampleRate */
2644 if (st->duration != AV_NOPTS_VALUE)
2645 st->duration = av_rescale_q(st->duration,
2646 av_inv_q(material_track->edit_rate),
2649 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2650 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2651 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2652 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2653 else if (descriptor->bits_per_sample == 32)
2654 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2655 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2656 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2657 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2658 else if (descriptor->bits_per_sample == 32)
2659 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2660 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2661 st->need_parsing = AVSTREAM_PARSE_FULL;
2663 st->codecpar->bits_per_coded_sample = av_get_bits_per_sample(st->codecpar->codec_id);
2664 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2665 enum AVMediaType type;
2666 container_ul = mxf_get_codec_ul(mxf_data_essence_container_uls, essence_container_ul);
2667 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2668 st->codecpar->codec_id = container_ul->id;
2669 type = avcodec_get_type(st->codecpar->codec_id);
2670 if (type == AVMEDIA_TYPE_SUBTITLE)
2671 st->codecpar->codec_type = type;
2672 if (container_ul->desc)
2673 av_dict_set(&st->metadata, "data_type", container_ul->desc, 0);
2674 if (mxf->eia608_extract &&
2675 !strcmp(container_ul->desc, "vbi_vanc_smpte_436M")) {
2676 st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
2677 st->codecpar->codec_id = AV_CODEC_ID_EIA_608;
2680 if (descriptor->extradata) {
2681 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2682 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2684 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2685 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2686 &descriptor->essence_codec_ul)->id;
2688 st->codecpar->width = coded_width;
2689 ret = ff_generate_avci_extradata(st);
2693 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
2694 /* TODO: decode timestamps */
2695 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2699 for (int i = 0; i < mxf->fc->nb_streams; i++) {
2700 MXFTrack *track1 = mxf->fc->streams[i]->priv_data;
2701 if (track1 && track1->body_sid) {
2702 for (int j = i + 1; j < mxf->fc->nb_streams; j++) {
2703 MXFTrack *track2 = mxf->fc->streams[j]->priv_data;
2704 if (track2 && track1->body_sid == track2->body_sid && track1->wrapping != track2->wrapping) {
2705 if (track1->wrapping == UnknownWrapped)
2706 track1->wrapping = track2->wrapping;
2707 else if (track2->wrapping == UnknownWrapped)
2708 track2->wrapping = track1->wrapping;
2710 av_log(mxf->fc, AV_LOG_ERROR, "stream %d and stream %d have the same BodySID (%d) "
2711 "with different wrapping\n", i, j, track1->body_sid);
2722 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2724 struct tm time = { 0 };
2726 time.tm_year = (timestamp >> 48) - 1900;
2727 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2728 time.tm_mday = (timestamp >> 32 & 0xFF);
2729 time.tm_hour = (timestamp >> 24 & 0xFF);
2730 time.tm_min = (timestamp >> 16 & 0xFF);
2731 time.tm_sec = (timestamp >> 8 & 0xFF);
2732 msecs = (timestamp & 0xFF) * 4;
2734 /* Clip values for legacy reasons. Maybe we should return error instead? */
2735 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2736 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2737 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2738 time.tm_min = av_clip(time.tm_min, 0, 59);
2739 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2740 msecs = av_clip(msecs, 0, 999);
2742 return (int64_t)av_timegm(&time) * 1000000 + msecs * 1000;
2745 #define SET_STR_METADATA(pb, name, str) do { \
2746 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2748 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2751 #define SET_VERSION_METADATA(pb, name, major, minor, tertiary, patch, release, str) do { \
2752 major = avio_rb16(pb); \
2753 minor = avio_rb16(pb); \
2754 tertiary = avio_rb16(pb); \
2755 patch = avio_rb16(pb); \
2756 release = avio_rb16(pb); \
2757 if ((ret = mxf_version_to_str(major, minor, tertiary, patch, release, &str)) < 0) \
2759 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2762 #define SET_UID_METADATA(pb, name, var, str) do { \
2763 avio_read(pb, var, 16); \
2764 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2766 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2769 #define SET_TS_METADATA(pb, name, var, str) do { \
2770 var = avio_rb64(pb); \
2771 if (var && (ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var))) < 0) \
2775 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2777 MXFContext *mxf = arg;
2778 AVFormatContext *s = mxf->fc;
2783 uint16_t major, minor, tertiary, patch, release;
2786 SET_STR_METADATA(pb, "company_name", str);
2789 SET_STR_METADATA(pb, "product_name", str);
2792 SET_VERSION_METADATA(pb, "product_version_num", major, minor, tertiary, patch, release, str);
2795 SET_STR_METADATA(pb, "product_version", str);
2798 SET_UID_METADATA(pb, "product_uid", uid, str);
2801 SET_TS_METADATA(pb, "modification_date", ts, str);
2804 SET_VERSION_METADATA(pb, "toolkit_version_num", major, minor, tertiary, patch, release, str);
2807 SET_STR_METADATA(pb, "application_platform", str);
2810 SET_UID_METADATA(pb, "generation_uid", uid, str);
2813 SET_UID_METADATA(pb, "uid", uid, str);
2819 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2821 MXFContext *mxf = arg;
2822 AVFormatContext *s = mxf->fc;
2826 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2827 SET_STR_METADATA(pb, "project_name", str);
2832 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2833 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2834 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2835 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2836 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2837 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2838 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2839 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2840 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2841 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2842 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2843 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2844 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2845 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2846 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2847 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2848 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2849 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2850 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2851 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2852 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2853 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2854 { { 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 */
2855 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2856 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2857 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2858 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2859 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2860 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5b,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VBI - SMPTE 436M */
2861 { { 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 */
2862 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2863 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x64,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* DC Timed Text Descriptor */
2864 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2865 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2866 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2867 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2868 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2869 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2870 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x23,0x00 }, mxf_read_essence_container_data, sizeof(MXFEssenceContainerData), EssenceContainerData },
2871 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2874 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2878 case MultipleDescriptor:
2880 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2881 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2889 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2891 AVIOContext *pb = mxf->fc->pb;
2892 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2893 uint64_t klv_end = avio_tell(pb) + klv->length;
2896 return AVERROR(ENOMEM);
2898 mxf_metadataset_init(ctx, type);
2899 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2901 int tag = avio_rb16(pb);
2902 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2903 int64_t next = avio_tell(pb);
2905 if (next < 0 || next > INT64_MAX - size)
2906 return next < 0 ? next : AVERROR_INVALIDDATA;
2909 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2910 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2911 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2914 if (tag > 0x7FFF) { /* dynamic tag */
2916 for (i = 0; i < mxf->local_tags_count; i++) {
2917 int local_tag = AV_RB16(mxf->local_tags+i*18);
2918 if (local_tag == tag) {
2919 memcpy(uid, mxf->local_tags+i*18+2, 16);
2920 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2921 PRINT_KEY(mxf->fc, "uid", uid);
2925 if (ctx_size && tag == 0x3C0A) {
2926 avio_read(pb, ctx->uid, 16);
2927 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2929 mxf_free_metadataset(&ctx, 1);
2933 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2934 * it extending past the end of the KLV though (zzuf5.mxf). */
2935 if (avio_tell(pb) > klv_end) {
2937 mxf_free_metadataset(&ctx, 1);
2940 av_log(mxf->fc, AV_LOG_ERROR,
2941 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2943 return AVERROR_INVALIDDATA;
2944 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2945 avio_seek(pb, next, SEEK_SET);
2947 return ctx_size ? mxf_add_metadata_set(mxf, &ctx) : 0;
2951 * Matches any partition pack key, in other words:
2955 * @return non-zero if the key is a partition pack key, zero otherwise
2957 static int mxf_is_partition_pack_key(UID key)
2959 //NOTE: this is a little lax since it doesn't constraint key[14]
2960 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2961 key[13] >= 2 && key[13] <= 4;
2965 * Parses a metadata KLV
2966 * @return <0 on error, 0 otherwise
2968 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2969 int ctx_size, enum MXFMetadataSetType type)
2971 AVFormatContext *s = mxf->fc;
2973 if (klv.key[5] == 0x53) {
2974 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2976 uint64_t next = avio_tell(s->pb) + klv.length;
2977 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2979 /* only seek forward, else this can loop for a long time */
2980 if (avio_tell(s->pb) > next) {
2981 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2983 return AVERROR_INVALIDDATA;
2986 avio_seek(s->pb, next, SEEK_SET);
2989 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2996 * Seeks to the previous partition and parses it, if possible
2997 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2999 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3001 AVIOContext *pb = mxf->fc->pb;
3003 int64_t current_partition_ofs;
3006 if (!mxf->current_partition ||
3007 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3008 return 0; /* we've parsed all partitions */
3010 /* seek to previous partition */
3011 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3012 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3013 mxf->current_partition = NULL;
3015 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3017 /* Make sure this is actually a PartitionPack, and if so parse it.
3020 if ((ret = klv_read_packet(&klv, pb)) < 0) {
3021 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3025 if (!mxf_is_partition_pack_key(klv.key)) {
3026 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3027 return AVERROR_INVALIDDATA;
3030 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3031 * can point to just before the current partition, causing klv_read_packet()
3032 * to sync back up to it. See deadlock3.mxf
3034 if (klv.offset >= current_partition_ofs) {
3035 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3036 PRIx64 " indirectly points to itself\n", current_partition_ofs);
3037 return AVERROR_INVALIDDATA;
3040 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3047 * Called when essence is encountered
3048 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3050 static int mxf_parse_handle_essence(MXFContext *mxf)
3052 AVIOContext *pb = mxf->fc->pb;
3055 if (mxf->parsing_backward) {
3056 return mxf_seek_to_previous_partition(mxf);
3058 if (!mxf->footer_partition) {
3059 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3063 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3065 /* remember where we were so we don't end up seeking further back than this */
3066 mxf->last_forward_tell = avio_tell(pb);
3068 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3069 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3073 /* seek to FooterPartition and parse backward */
3074 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3075 av_log(mxf->fc, AV_LOG_ERROR,
3076 "failed to seek to FooterPartition @ 0x%" PRIx64
3077 " (%"PRId64") - partial file?\n",
3078 mxf->run_in + mxf->footer_partition, ret);
3082 mxf->current_partition = NULL;
3083 mxf->parsing_backward = 1;
3090 * Called when the next partition or EOF is encountered
3091 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3093 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3095 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3098 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3100 for (int i = 0; i < s->nb_streams; i++) {
3101 MXFTrack *track = s->streams[i]->priv_data;
3102 if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3103 return track->wrapping;
3105 return UnknownWrapped;
3109 * Figures out the proper offset and length of the essence container in each partition
3111 static void mxf_compute_essence_containers(AVFormatContext *s)
3113 MXFContext *mxf = s->priv_data;
3116 for (x = 0; x < mxf->partitions_count; x++) {
3117 MXFPartition *p = &mxf->partitions[x];
3118 MXFWrappingScheme wrapping;
3121 continue; /* BodySID == 0 -> no essence */
3123 /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3124 * otherwise we point essence_offset at the key of the first essence KLV.
3127 wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3129 if (wrapping == ClipWrapped) {
3130 p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3131 p->essence_length = p->first_essence_klv.length;
3133 p->essence_offset = p->first_essence_klv.offset;
3135 /* essence container spans to the next partition */
3136 if (x < mxf->partitions_count - 1)
3137 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
3139 if (p->essence_length < 0) {
3140 /* next ThisPartition < essence_offset */
3141 p->essence_length = 0;
3142 av_log(mxf->fc, AV_LOG_ERROR,
3143 "partition %i: bad ThisPartition = %"PRIX64"\n",
3144 x+1, mxf->partitions[x+1].this_partition);
3150 static int is_pcm(enum AVCodecID codec_id)
3152 /* we only care about "normal" PCM codecs until we get samples */
3153 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
3156 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3159 for (i = 0; i < mxf->nb_index_tables; i++)
3160 if (mxf->index_tables[i].index_sid == index_sid)
3161 return &mxf->index_tables[i];
3166 * Deal with the case where for some audio atoms EditUnitByteCount is
3167 * very small (2, 4..). In those cases we should read more than one
3168 * sample per call to mxf_read_packet().
3170 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3172 MXFTrack *track = st->priv_data;
3177 track->edit_units_per_packet = 1;
3178 if (track->wrapping != ClipWrapped)
3181 t = mxf_find_index_table(mxf, track->index_sid);
3183 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3184 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3185 !is_pcm(st->codecpar->codec_id) ||
3187 t->nb_segments != 1 ||
3188 t->segments[0]->edit_unit_byte_count >= 32)
3191 /* arbitrarily default to 48 kHz PAL audio frame size */
3192 /* TODO: We could compute this from the ratio between the audio
3193 * and video edit rates for 48 kHz NTSC we could use the
3194 * 1802-1802-1802-1802-1801 pattern. */
3195 track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3199 * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3201 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3203 MXFTrack *track = st->priv_data;
3204 MXFIndexTableSegment *segment = NULL;
3205 MXFPartition *p = NULL;
3206 int essence_partition_count = 0;
3207 int edit_unit_byte_count = 0;
3210 if (!track || track->wrapping != ClipWrapped)
3213 /* check if track already has an IndexTableSegment */
3214 for (i = 0; i < mxf->metadata_sets_count; i++) {
3215 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3216 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3217 if (s->body_sid == track->body_sid)
3222 /* find the essence partition */
3223 for (i = 0; i < mxf->partitions_count; i++) {
3224 /* BodySID == 0 -> no essence */
3225 if (mxf->partitions[i].body_sid != track->body_sid)
3228 p = &mxf->partitions[i];
3229 essence_partition_count++;
3232 /* only handle files with a single essence partition */
3233 if (essence_partition_count != 1)
3236 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3237 edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3238 } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3239 edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3242 if (edit_unit_byte_count <= 0)
3245 av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
3247 if (!(segment = av_mallocz(sizeof(*segment))))
3248 return AVERROR(ENOMEM);
3250 if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3253 /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3254 * using the same SID for index is forbidden in MXF. */
3255 if (!track->index_sid)
3256 track->index_sid = track->body_sid;
3258 segment->type = IndexTableSegment;
3259 /* stream will be treated as small EditUnitByteCount */
3260 segment->edit_unit_byte_count = edit_unit_byte_count;
3261 segment->index_start_position = 0;
3262 segment->index_duration = st->duration;
3263 segment->index_edit_rate = av_inv_q(st->time_base);
3264 segment->index_sid = track->index_sid;
3265 segment->body_sid = p->body_sid;
3269 static void mxf_read_random_index_pack(AVFormatContext *s)
3271 MXFContext *mxf = s->priv_data;
3273 int64_t file_size, max_rip_length, min_rip_length;
3276 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3279 file_size = avio_size(s->pb);
3281 /* S377m says to check the RIP length for "silly" values, without defining "silly".
3282 * The limit below assumes a file with nothing but partition packs and a RIP.
3283 * Before changing this, consider that a muxer may place each sample in its own partition.
3285 * 105 is the size of the smallest possible PartitionPack
3286 * 12 is the size of each RIP entry
3287 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3289 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3290 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3292 /* We're only interested in RIPs with at least two entries.. */
3293 min_rip_length = 16+1+24+4;
3295 /* See S377m section 11 */
3296 avio_seek(s->pb, file_size - 4, SEEK_SET);
3297 length = avio_rb32(s->pb);
3299 if (length < min_rip_length || length > max_rip_length)
3301 avio_seek(s->pb, file_size - length, SEEK_SET);
3302 if (klv_read_packet(&klv, s->pb) < 0 ||
3303 !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3305 if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3306 av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3310 avio_skip(s->pb, klv.length - 12);
3311 mxf->footer_partition = avio_rb64(s->pb);
3314 if (mxf->run_in + mxf->footer_partition >= file_size) {
3315 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3316 mxf->footer_partition = 0;
3320 avio_seek(s->pb, mxf->run_in, SEEK_SET);
3323 static int mxf_read_header(AVFormatContext *s)
3325 MXFContext *mxf = s->priv_data;
3327 int64_t essence_offset = 0;
3330 mxf->last_forward_tell = INT64_MAX;
3332 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3333 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3334 //goto fail should not be needed as no metadata sets will have been parsed yet
3335 return AVERROR_INVALIDDATA;
3337 avio_seek(s->pb, -14, SEEK_CUR);
3339 mxf->run_in = avio_tell(s->pb);
3341 mxf_read_random_index_pack(s);
3343 while (!avio_feof(s->pb)) {
3344 const MXFMetadataReadTableEntry *metadata;
3346 if (klv_read_packet(&klv, s->pb) < 0) {
3347 /* EOF - seek to previous partition or stop */
3348 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3354 PRINT_KEY(s, "read header", klv.key);
3355 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3356 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3357 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3358 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3359 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3360 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3361 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3363 if (!mxf->current_partition) {
3364 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3365 ret = AVERROR_INVALIDDATA;
3369 if (!mxf->current_partition->first_essence_klv.offset)
3370 mxf->current_partition->first_essence_klv = klv;
3372 if (!essence_offset)
3373 essence_offset = klv.offset;
3375 /* seek to footer, previous partition or stop */
3376 if (mxf_parse_handle_essence(mxf) <= 0)
3379 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3380 /* next partition pack - keep going, seek to previous partition or stop */
3381 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3383 else if (mxf->parsing_backward)
3385 /* we're still parsing forward. proceed to parsing this partition pack */
3388 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3389 if (IS_KLV_KEY(klv.key, metadata->key)) {
3390 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3395 if (!metadata->read) {
3396 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3398 avio_skip(s->pb, klv.length);
3401 /* FIXME avoid seek */
3402 if (!essence_offset) {
3403 av_log(s, AV_LOG_ERROR, "no essence\n");
3404 ret = AVERROR_INVALIDDATA;
3407 avio_seek(s->pb, essence_offset, SEEK_SET);
3409 /* we need to do this before computing the index tables
3410 * to be able to fill in zero IndexDurations with st->duration */
3411 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3414 for (int i = 0; i < s->nb_streams; i++)
3415 mxf_handle_missing_index_segment(mxf, s->streams[i]);
3417 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3420 if (mxf->nb_index_tables > 1) {
3421 /* TODO: look up which IndexSID to use via EssenceContainerData */
3422 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3423 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3424 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3425 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3426 ret = AVERROR_INVALIDDATA;
3430 mxf_compute_essence_containers(s);
3432 for (int i = 0; i < s->nb_streams; i++)
3433 mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3442 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3443 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3445 int64_t a, b, m, offset;
3446 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3448 if (!t || track->original_duration <= 0)
3452 b = track->original_duration;
3456 if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3458 if (offset < current_offset)
3469 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3472 MXFTrack *track = st->priv_data;
3473 AVRational time_base = av_inv_q(track->edit_rate);
3474 AVRational sample_rate = av_inv_q(st->time_base);
3476 // For non-audio sample_count equals current edit unit
3477 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3480 if ((sample_rate.num / sample_rate.den) == 48000) {
3481 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3483 int remainder = (sample_rate.num * time_base.num) %
3484 (time_base.den * sample_rate.den);
3486 av_log(mxf->fc, AV_LOG_WARNING,
3487 "seeking detected on stream #%d with time base (%d/%d) and "
3488 "sample rate (%d/%d), audio pts won't be accurate.\n",
3489 st->index, time_base.num, time_base.den,
3490 sample_rate.num, sample_rate.den);
3491 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3496 * Make sure track->sample_count is correct based on what offset we're currently at.
3497 * Also determine the next edit unit (or packet) offset.
3498 * @return next_ofs if OK, <0 on error
3500 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3502 int64_t next_ofs = -1;
3503 MXFTrack *track = st->priv_data;
3504 int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3505 int64_t new_edit_unit;
3506 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3508 if (!t || track->wrapping == UnknownWrapped)
3511 if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3512 (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3513 av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3517 /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3518 if (next_ofs > current_offset)
3522 av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3526 if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3527 av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3532 track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3533 av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
3535 return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3538 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3541 AVStream *st = mxf->fc->streams[pkt->stream_index];
3542 MXFTrack *track = st->priv_data;
3543 int64_t bits_per_sample = par->bits_per_coded_sample;
3545 if (!bits_per_sample)
3546 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3548 pkt->pts = track->sample_count;
3550 if ( par->channels <= 0
3551 || bits_per_sample <= 0
3552 || par->channels * (int64_t)bits_per_sample < 8)
3553 track->sample_count = mxf_compute_sample_count(mxf, st, av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate)) + 1);
3555 track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3560 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3562 AVCodecParameters *par = st->codecpar;
3563 MXFTrack *track = st->priv_data;
3565 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3566 /* see if we have an index table to derive timestamps from */
3567 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3569 if (t && track->sample_count < t->nb_ptses) {
3570 pkt->dts = track->sample_count + t->first_dts;
3571 pkt->pts = t->ptses[track->sample_count];
3572 } else if (track->intra_only) {
3573 /* intra-only -> PTS = EditUnit.
3574 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3575 pkt->pts = track->sample_count;
3577 track->sample_count++;
3578 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3579 int ret = mxf_set_audio_pts(mxf, par, pkt);
3583 pkt->dts = pkt->pts = track->sample_count;
3585 track->sample_count++;
3590 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3593 MXFContext *mxf = s->priv_data;
3597 int64_t max_data_size;
3598 int64_t pos = avio_tell(s->pb);
3600 if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3601 mxf->current_klv_data = (KLVPacket){{0}};
3602 ret = klv_read_packet(&klv, s->pb);
3605 max_data_size = klv.length;
3606 pos = klv.next_klv - klv.length;
3607 PRINT_KEY(s, "read packet", klv.key);
3608 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3609 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3610 ret = mxf_decrypt_triplet(s, pkt, &klv);
3612 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3618 klv = mxf->current_klv_data;
3619 max_data_size = klv.next_klv - pos;
3621 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3622 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3623 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3624 int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3625 int index = mxf_get_stream_index(s, &klv, body_sid);
3631 av_log(s, AV_LOG_ERROR,
3632 "error getting stream index %"PRIu32"\n",
3633 AV_RB32(klv.key + 12));
3637 st = s->streams[index];
3638 track = st->priv_data;
3640 if (s->streams[index]->discard == AVDISCARD_ALL)
3643 next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3645 if (track->wrapping != FrameWrapped) {
3648 if (next_ofs <= 0) {
3649 // If we have no way to packetize the data, then return it in chunks...
3650 if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3651 st->need_parsing = AVSTREAM_PARSE_FULL;
3652 avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3654 size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3656 if ((size = next_ofs - pos) <= 0) {
3657 av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3658 mxf->current_klv_data = (KLVPacket){{0}};
3659 return AVERROR_INVALIDDATA;
3661 // We must not overread, because the next edit unit might be in another KLV
3662 if (size > max_data_size)
3663 size = max_data_size;
3666 mxf->current_klv_data = klv;
3669 klv.next_klv = klv.offset + klv.length;
3672 /* check for 8 channels AES3 element */
3673 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3674 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3677 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3678 mxf->current_klv_data = (KLVPacket){{0}};
3681 } else if (mxf->eia608_extract &&
3682 s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3683 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3685 mxf->current_klv_data = (KLVPacket){{0}};
3689 ret = av_get_packet(s->pb, pkt, klv.length);
3691 mxf->current_klv_data = (KLVPacket){{0}};
3695 pkt->stream_index = index;
3696 pkt->pos = klv.offset;
3698 ret = mxf_set_pts(mxf, st, pkt);
3700 mxf->current_klv_data = (KLVPacket){{0}};
3704 /* seek for truncated packets */
3705 avio_seek(s->pb, klv.next_klv, SEEK_SET);
3710 avio_skip(s->pb, max_data_size);
3711 mxf->current_klv_data = (KLVPacket){{0}};
3714 return avio_feof(s->pb) ? AVERROR_EOF : ret;
3717 static int mxf_read_close(AVFormatContext *s)
3719 MXFContext *mxf = s->priv_data;
3722 av_freep(&mxf->packages_refs);
3723 av_freep(&mxf->essence_container_data_refs);
3725 for (i = 0; i < s->nb_streams; i++)
3726 s->streams[i]->priv_data = NULL;
3728 for (i = 0; i < mxf->metadata_sets_count; i++) {
3729 mxf_free_metadataset(mxf->metadata_sets + i, 1);
3731 mxf->metadata_sets_count = 0;
3732 av_freep(&mxf->partitions);
3733 av_freep(&mxf->metadata_sets);
3734 av_freep(&mxf->aesc);
3735 av_freep(&mxf->local_tags);
3737 if (mxf->index_tables) {
3738 for (i = 0; i < mxf->nb_index_tables; i++) {
3739 av_freep(&mxf->index_tables[i].segments);
3740 av_freep(&mxf->index_tables[i].ptses);
3741 av_freep(&mxf->index_tables[i].fake_index);
3742 av_freep(&mxf->index_tables[i].offsets);
3745 av_freep(&mxf->index_tables);
3750 static int mxf_probe(const AVProbeData *p) {
3751 const uint8_t *bufp = p->buf;
3752 const uint8_t *end = p->buf + p->buf_size;
3754 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3757 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3758 end -= sizeof(mxf_header_partition_pack_key);
3760 for (; bufp < end;) {
3761 if (!((bufp[13] - 1) & 0xF2)){
3762 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3763 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3764 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3765 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3766 return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
3775 /* rudimentary byte seek */
3776 /* XXX: use MXF Index */
3777 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3779 AVStream *st = s->streams[stream_index];
3781 MXFContext* mxf = s->priv_data;
3785 MXFTrack *source_track = st->priv_data;
3790 /* if audio then truncate sample_time to EditRate */
3791 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3792 sample_time = av_rescale_q(sample_time, st->time_base,
3793 av_inv_q(source_track->edit_rate));
3795 if (mxf->nb_index_tables <= 0) {
3797 return AVERROR_INVALIDDATA;
3798 if (sample_time < 0)
3800 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3802 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3806 ff_update_cur_dts(s, st, sample_time);
3807 mxf->current_klv_data = (KLVPacket){{0}};
3809 MXFPartition *partition;
3811 t = &mxf->index_tables[0];
3812 if (t->index_sid != source_track->index_sid) {
3813 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3814 for (i = 0; i < s->nb_streams; i++) {
3815 MXFTrack *new_source_track = s->streams[i]->priv_data;
3816 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3817 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3818 source_track = new_source_track;
3823 if (i == s->nb_streams)
3824 return AVERROR_INVALIDDATA;
3827 /* clamp above zero, else ff_index_search_timestamp() returns negative
3828 * this also means we allow seeking before the start */
3829 sample_time = FFMAX(sample_time, 0);
3831 if (t->fake_index) {
3832 /* The first frames may not be keyframes in presentation order, so
3833 * we have to advance the target to be able to find the first
3834 * keyframe backwards... */
3835 if (!(flags & AVSEEK_FLAG_ANY) &&
3836 (flags & AVSEEK_FLAG_BACKWARD) &&
3837 t->ptses[0] != AV_NOPTS_VALUE &&
3838 sample_time < t->ptses[0] &&
3839 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3840 sample_time = t->ptses[0];
3842 /* behave as if we have a proper index */
3843 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3845 /* get the stored order index from the display order index */
3846 sample_time += t->offsets[sample_time];
3848 /* no IndexEntryArray (one or more CBR segments)
3849 * make sure we don't seek past the end */
3850 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3853 if (source_track->wrapping == UnknownWrapped)
3854 av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3856 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3859 ff_update_cur_dts(s, st, sample_time);
3860 if (source_track->wrapping == ClipWrapped) {
3861 KLVPacket klv = partition->first_essence_klv;
3862 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3863 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3864 return AVERROR_INVALIDDATA;
3866 mxf->current_klv_data = klv;
3868 mxf->current_klv_data = (KLVPacket){{0}};
3870 avio_seek(s->pb, seekpos, SEEK_SET);
3873 // Update all tracks sample count
3874 for (i = 0; i < s->nb_streams; i++) {
3875 AVStream *cur_st = s->streams[i];
3876 MXFTrack *cur_track = cur_st->priv_data;
3878 int64_t track_edit_unit = sample_time;
3880 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3881 cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3887 static const AVOption options[] = {
3888 { "eia608_extract", "extract eia 608 captions from s436m track",
3889 offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3890 AV_OPT_FLAG_DECODING_PARAM },
3894 static const AVClass demuxer_class = {
3895 .class_name = "mxf",
3896 .item_name = av_default_item_name,
3898 .version = LIBAVUTIL_VERSION_INT,
3899 .category = AV_CLASS_CATEGORY_DEMUXER,
3902 AVInputFormat ff_mxf_demuxer = {
3904 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3905 .flags = AVFMT_SEEK_TO_PTS,
3906 .priv_data_size = sizeof(MXFContext),
3907 .read_probe = mxf_probe,
3908 .read_header = mxf_read_header,
3909 .read_packet = mxf_read_packet,
3910 .read_close = mxf_read_close,
3911 .read_seek = mxf_read_seek,
3912 .priv_class = &demuxer_class,