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 uint64_t klv_end = avio_tell(pb) + klv->length;
2893 MXFMetadataSet *meta;
2897 meta = av_mallocz(ctx_size);
2899 return AVERROR(ENOMEM);
2901 mxf_metadataset_init(meta, type);
2906 while (avio_tell(pb) + 4ULL < klv_end && !avio_feof(pb)) {
2908 int tag = avio_rb16(pb);
2909 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2910 int64_t next = avio_tell(pb);
2912 if (next < 0 || next > INT64_MAX - size) {
2914 mxf_free_metadataset(&meta, 1);
2916 return next < 0 ? next : AVERROR_INVALIDDATA;
2920 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2921 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2922 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2925 if (tag > 0x7FFF) { /* dynamic tag */
2927 for (i = 0; i < mxf->local_tags_count; i++) {
2928 int local_tag = AV_RB16(mxf->local_tags+i*18);
2929 if (local_tag == tag) {
2930 memcpy(uid, mxf->local_tags+i*18+2, 16);
2931 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2932 PRINT_KEY(mxf->fc, "uid", uid);
2936 if (meta && tag == 0x3C0A) {
2937 avio_read(pb, meta->uid, 16);
2938 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2940 mxf_free_metadataset(&meta, 1);
2945 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2946 * it extending past the end of the KLV though (zzuf5.mxf). */
2947 if (avio_tell(pb) > klv_end) {
2949 mxf_free_metadataset(&meta, 1);
2952 av_log(mxf->fc, AV_LOG_ERROR,
2953 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2955 return AVERROR_INVALIDDATA;
2956 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2957 avio_seek(pb, next, SEEK_SET);
2959 return meta ? mxf_add_metadata_set(mxf, &meta) : 0;
2963 * Matches any partition pack key, in other words:
2967 * @return non-zero if the key is a partition pack key, zero otherwise
2969 static int mxf_is_partition_pack_key(UID key)
2971 //NOTE: this is a little lax since it doesn't constraint key[14]
2972 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2973 key[13] >= 2 && key[13] <= 4;
2977 * Parses a metadata KLV
2978 * @return <0 on error, 0 otherwise
2980 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2981 int ctx_size, enum MXFMetadataSetType type)
2983 AVFormatContext *s = mxf->fc;
2985 if (klv.key[5] == 0x53) {
2986 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2988 uint64_t next = avio_tell(s->pb) + klv.length;
2989 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2991 /* only seek forward, else this can loop for a long time */
2992 if (avio_tell(s->pb) > next) {
2993 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2995 return AVERROR_INVALIDDATA;
2998 avio_seek(s->pb, next, SEEK_SET);
3001 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
3008 * Seeks to the previous partition and parses it, if possible
3009 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3011 static int mxf_seek_to_previous_partition(MXFContext *mxf)
3013 AVIOContext *pb = mxf->fc->pb;
3015 int64_t current_partition_ofs;
3018 if (!mxf->current_partition ||
3019 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
3020 return 0; /* we've parsed all partitions */
3022 /* seek to previous partition */
3023 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
3024 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
3025 mxf->current_partition = NULL;
3027 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
3029 /* Make sure this is actually a PartitionPack, and if so parse it.
3032 if ((ret = klv_read_packet(&klv, pb)) < 0) {
3033 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
3037 if (!mxf_is_partition_pack_key(klv.key)) {
3038 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
3039 return AVERROR_INVALIDDATA;
3042 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
3043 * can point to just before the current partition, causing klv_read_packet()
3044 * to sync back up to it. See deadlock3.mxf
3046 if (klv.offset >= current_partition_ofs) {
3047 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
3048 PRIx64 " indirectly points to itself\n", current_partition_ofs);
3049 return AVERROR_INVALIDDATA;
3052 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
3059 * Called when essence is encountered
3060 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3062 static int mxf_parse_handle_essence(MXFContext *mxf)
3064 AVIOContext *pb = mxf->fc->pb;
3067 if (mxf->parsing_backward) {
3068 return mxf_seek_to_previous_partition(mxf);
3070 if (!mxf->footer_partition) {
3071 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
3075 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
3077 /* remember where we were so we don't end up seeking further back than this */
3078 mxf->last_forward_tell = avio_tell(pb);
3080 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
3081 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
3085 /* seek to FooterPartition and parse backward */
3086 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
3087 av_log(mxf->fc, AV_LOG_ERROR,
3088 "failed to seek to FooterPartition @ 0x%" PRIx64
3089 " (%"PRId64") - partial file?\n",
3090 mxf->run_in + mxf->footer_partition, ret);
3094 mxf->current_partition = NULL;
3095 mxf->parsing_backward = 1;
3102 * Called when the next partition or EOF is encountered
3103 * @return <= 0 if we should stop parsing, > 0 if we should keep going
3105 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
3107 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
3110 static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
3112 for (int i = 0; i < s->nb_streams; i++) {
3113 MXFTrack *track = s->streams[i]->priv_data;
3114 if (track && track->body_sid == body_sid && track->wrapping != UnknownWrapped)
3115 return track->wrapping;
3117 return UnknownWrapped;
3121 * Figures out the proper offset and length of the essence container in each partition
3123 static void mxf_compute_essence_containers(AVFormatContext *s)
3125 MXFContext *mxf = s->priv_data;
3128 for (x = 0; x < mxf->partitions_count; x++) {
3129 MXFPartition *p = &mxf->partitions[x];
3130 MXFWrappingScheme wrapping;
3133 continue; /* BodySID == 0 -> no essence */
3135 /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
3136 * otherwise we point essence_offset at the key of the first essence KLV.
3139 wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
3141 if (wrapping == ClipWrapped) {
3142 p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
3143 p->essence_length = p->first_essence_klv.length;
3145 p->essence_offset = p->first_essence_klv.offset;
3147 /* essence container spans to the next partition */
3148 if (x < mxf->partitions_count - 1)
3149 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
3151 if (p->essence_length < 0) {
3152 /* next ThisPartition < essence_offset */
3153 p->essence_length = 0;
3154 av_log(mxf->fc, AV_LOG_ERROR,
3155 "partition %i: bad ThisPartition = %"PRIX64"\n",
3156 x+1, mxf->partitions[x+1].this_partition);
3162 static int is_pcm(enum AVCodecID codec_id)
3164 /* we only care about "normal" PCM codecs until we get samples */
3165 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
3168 static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
3171 for (i = 0; i < mxf->nb_index_tables; i++)
3172 if (mxf->index_tables[i].index_sid == index_sid)
3173 return &mxf->index_tables[i];
3178 * Deal with the case where for some audio atoms EditUnitByteCount is
3179 * very small (2, 4..). In those cases we should read more than one
3180 * sample per call to mxf_read_packet().
3182 static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
3184 MXFTrack *track = st->priv_data;
3189 track->edit_units_per_packet = 1;
3190 if (track->wrapping != ClipWrapped)
3193 t = mxf_find_index_table(mxf, track->index_sid);
3195 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
3196 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
3197 !is_pcm(st->codecpar->codec_id) ||
3199 t->nb_segments != 1 ||
3200 t->segments[0]->edit_unit_byte_count >= 32)
3203 /* arbitrarily default to 48 kHz PAL audio frame size */
3204 /* TODO: We could compute this from the ratio between the audio
3205 * and video edit rates for 48 kHz NTSC we could use the
3206 * 1802-1802-1802-1802-1801 pattern. */
3207 track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
3211 * Deal with the case where ClipWrapped essences does not have any IndexTableSegments.
3213 static int mxf_handle_missing_index_segment(MXFContext *mxf, AVStream *st)
3215 MXFTrack *track = st->priv_data;
3216 MXFIndexTableSegment *segment = NULL;
3217 MXFPartition *p = NULL;
3218 int essence_partition_count = 0;
3219 int edit_unit_byte_count = 0;
3222 if (!track || track->wrapping != ClipWrapped)
3225 /* check if track already has an IndexTableSegment */
3226 for (i = 0; i < mxf->metadata_sets_count; i++) {
3227 if (mxf->metadata_sets[i]->type == IndexTableSegment) {
3228 MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
3229 if (s->body_sid == track->body_sid)
3234 /* find the essence partition */
3235 for (i = 0; i < mxf->partitions_count; i++) {
3236 /* BodySID == 0 -> no essence */
3237 if (mxf->partitions[i].body_sid != track->body_sid)
3240 p = &mxf->partitions[i];
3241 essence_partition_count++;
3244 /* only handle files with a single essence partition */
3245 if (essence_partition_count != 1)
3248 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
3249 edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
3250 } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
3251 edit_unit_byte_count = p->first_essence_klv.length / st->duration;
3254 if (edit_unit_byte_count <= 0)
3257 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);
3259 if (!(segment = av_mallocz(sizeof(*segment))))
3260 return AVERROR(ENOMEM);
3262 if ((ret = mxf_add_metadata_set(mxf, (MXFMetadataSet**)&segment)))
3265 /* Make sure we have nonzero unique index_sid, body_sid will be ok, because
3266 * using the same SID for index is forbidden in MXF. */
3267 if (!track->index_sid)
3268 track->index_sid = track->body_sid;
3270 segment->type = IndexTableSegment;
3271 /* stream will be treated as small EditUnitByteCount */
3272 segment->edit_unit_byte_count = edit_unit_byte_count;
3273 segment->index_start_position = 0;
3274 segment->index_duration = st->duration;
3275 segment->index_edit_rate = av_inv_q(st->time_base);
3276 segment->index_sid = track->index_sid;
3277 segment->body_sid = p->body_sid;
3281 static void mxf_read_random_index_pack(AVFormatContext *s)
3283 MXFContext *mxf = s->priv_data;
3285 int64_t file_size, max_rip_length, min_rip_length;
3288 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
3291 file_size = avio_size(s->pb);
3293 /* S377m says to check the RIP length for "silly" values, without defining "silly".
3294 * The limit below assumes a file with nothing but partition packs and a RIP.
3295 * Before changing this, consider that a muxer may place each sample in its own partition.
3297 * 105 is the size of the smallest possible PartitionPack
3298 * 12 is the size of each RIP entry
3299 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
3301 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
3302 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
3304 /* We're only interested in RIPs with at least two entries.. */
3305 min_rip_length = 16+1+24+4;
3307 /* See S377m section 11 */
3308 avio_seek(s->pb, file_size - 4, SEEK_SET);
3309 length = avio_rb32(s->pb);
3311 if (length < min_rip_length || length > max_rip_length)
3313 avio_seek(s->pb, file_size - length, SEEK_SET);
3314 if (klv_read_packet(&klv, s->pb) < 0 ||
3315 !IS_KLV_KEY(klv.key, ff_mxf_random_index_pack_key))
3317 if (klv.next_klv != file_size || klv.length <= 4 || (klv.length - 4) % 12) {
3318 av_log(s, AV_LOG_WARNING, "Invalid RIP KLV length\n");
3322 avio_skip(s->pb, klv.length - 12);
3323 mxf->footer_partition = avio_rb64(s->pb);
3326 if (mxf->run_in + mxf->footer_partition >= file_size) {
3327 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
3328 mxf->footer_partition = 0;
3332 avio_seek(s->pb, mxf->run_in, SEEK_SET);
3335 static int mxf_read_header(AVFormatContext *s)
3337 MXFContext *mxf = s->priv_data;
3339 int64_t essence_offset = 0;
3342 mxf->last_forward_tell = INT64_MAX;
3344 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
3345 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
3346 //goto fail should not be needed as no metadata sets will have been parsed yet
3347 return AVERROR_INVALIDDATA;
3349 avio_seek(s->pb, -14, SEEK_CUR);
3351 mxf->run_in = avio_tell(s->pb);
3353 mxf_read_random_index_pack(s);
3355 while (!avio_feof(s->pb)) {
3356 const MXFMetadataReadTableEntry *metadata;
3358 if (klv_read_packet(&klv, s->pb) < 0) {
3359 /* EOF - seek to previous partition or stop */
3360 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3366 PRINT_KEY(s, "read header", klv.key);
3367 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3368 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
3369 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3370 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3371 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
3372 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
3373 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
3375 if (!mxf->current_partition) {
3376 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
3377 ret = AVERROR_INVALIDDATA;
3381 if (!mxf->current_partition->first_essence_klv.offset)
3382 mxf->current_partition->first_essence_klv = klv;
3384 if (!essence_offset)
3385 essence_offset = klv.offset;
3387 /* seek to footer, previous partition or stop */
3388 if (mxf_parse_handle_essence(mxf) <= 0)
3391 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
3392 /* next partition pack - keep going, seek to previous partition or stop */
3393 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
3395 else if (mxf->parsing_backward)
3397 /* we're still parsing forward. proceed to parsing this partition pack */
3400 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
3401 if (IS_KLV_KEY(klv.key, metadata->key)) {
3402 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
3407 if (!metadata->read) {
3408 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
3410 avio_skip(s->pb, klv.length);
3413 /* FIXME avoid seek */
3414 if (!essence_offset) {
3415 av_log(s, AV_LOG_ERROR, "no essence\n");
3416 ret = AVERROR_INVALIDDATA;
3419 avio_seek(s->pb, essence_offset, SEEK_SET);
3421 /* we need to do this before computing the index tables
3422 * to be able to fill in zero IndexDurations with st->duration */
3423 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
3426 for (int i = 0; i < s->nb_streams; i++)
3427 mxf_handle_missing_index_segment(mxf, s->streams[i]);
3429 if ((ret = mxf_compute_index_tables(mxf)) < 0)
3432 if (mxf->nb_index_tables > 1) {
3433 /* TODO: look up which IndexSID to use via EssenceContainerData */
3434 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
3435 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
3436 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
3437 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
3438 ret = AVERROR_INVALIDDATA;
3442 mxf_compute_essence_containers(s);
3444 for (int i = 0; i < s->nb_streams; i++)
3445 mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
3454 /* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
3455 static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
3457 int64_t a, b, m, offset;
3458 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3460 if (!t || track->original_duration <= 0)
3464 b = track->original_duration;
3468 if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
3470 if (offset < current_offset)
3481 static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
3484 MXFTrack *track = st->priv_data;
3485 AVRational time_base = av_inv_q(track->edit_rate);
3486 AVRational sample_rate = av_inv_q(st->time_base);
3488 // For non-audio sample_count equals current edit unit
3489 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
3492 if ((sample_rate.num / sample_rate.den) == 48000) {
3493 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3495 int remainder = (sample_rate.num * time_base.num) %
3496 (time_base.den * sample_rate.den);
3498 av_log(mxf->fc, AV_LOG_WARNING,
3499 "seeking detected on stream #%d with time base (%d/%d) and "
3500 "sample rate (%d/%d), audio pts won't be accurate.\n",
3501 st->index, time_base.num, time_base.den,
3502 sample_rate.num, sample_rate.den);
3503 return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
3508 * Make sure track->sample_count is correct based on what offset we're currently at.
3509 * Also determine the next edit unit (or packet) offset.
3510 * @return next_ofs if OK, <0 on error
3512 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
3514 int64_t next_ofs = -1;
3515 MXFTrack *track = st->priv_data;
3516 int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
3517 int64_t new_edit_unit;
3518 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3520 if (!t || track->wrapping == UnknownWrapped)
3523 if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
3524 (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3525 av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3529 /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
3530 if (next_ofs > current_offset)
3534 av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
3538 if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
3539 av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
3544 track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
3545 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);
3547 return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
3550 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3553 AVStream *st = mxf->fc->streams[pkt->stream_index];
3554 MXFTrack *track = st->priv_data;
3555 int64_t bits_per_sample = par->bits_per_coded_sample;
3557 if (!bits_per_sample)
3558 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3560 pkt->pts = track->sample_count;
3562 if ( par->channels <= 0
3563 || bits_per_sample <= 0
3564 || par->channels * (int64_t)bits_per_sample < 8)
3565 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);
3567 track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3572 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
3574 AVCodecParameters *par = st->codecpar;
3575 MXFTrack *track = st->priv_data;
3577 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
3578 /* see if we have an index table to derive timestamps from */
3579 MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
3581 if (t && track->sample_count < t->nb_ptses) {
3582 pkt->dts = track->sample_count + t->first_dts;
3583 pkt->pts = t->ptses[track->sample_count];
3584 } else if (track->intra_only) {
3585 /* intra-only -> PTS = EditUnit.
3586 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3587 pkt->pts = track->sample_count;
3589 track->sample_count++;
3590 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3591 int ret = mxf_set_audio_pts(mxf, par, pkt);
3595 pkt->dts = pkt->pts = track->sample_count;
3597 track->sample_count++;
3602 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3605 MXFContext *mxf = s->priv_data;
3609 int64_t max_data_size;
3610 int64_t pos = avio_tell(s->pb);
3612 if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
3613 mxf->current_klv_data = (KLVPacket){{0}};
3614 ret = klv_read_packet(&klv, s->pb);
3617 max_data_size = klv.length;
3618 pos = klv.next_klv - klv.length;
3619 PRINT_KEY(s, "read packet", klv.key);
3620 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3621 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3622 ret = mxf_decrypt_triplet(s, pkt, &klv);
3624 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3630 klv = mxf->current_klv_data;
3631 max_data_size = klv.next_klv - pos;
3633 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3634 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3635 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3636 int body_sid = find_body_sid_by_absolute_offset(mxf, klv.offset);
3637 int index = mxf_get_stream_index(s, &klv, body_sid);
3643 av_log(s, AV_LOG_ERROR,
3644 "error getting stream index %"PRIu32"\n",
3645 AV_RB32(klv.key + 12));
3649 st = s->streams[index];
3650 track = st->priv_data;
3652 if (s->streams[index]->discard == AVDISCARD_ALL)
3655 next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
3657 if (track->wrapping != FrameWrapped) {
3660 if (next_ofs <= 0) {
3661 // If we have no way to packetize the data, then return it in chunks...
3662 if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
3663 st->need_parsing = AVSTREAM_PARSE_FULL;
3664 avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
3666 size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
3668 if ((size = next_ofs - pos) <= 0) {
3669 av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
3670 mxf->current_klv_data = (KLVPacket){{0}};
3671 return AVERROR_INVALIDDATA;
3673 // We must not overread, because the next edit unit might be in another KLV
3674 if (size > max_data_size)
3675 size = max_data_size;
3678 mxf->current_klv_data = klv;
3681 klv.next_klv = klv.offset + klv.length;
3684 /* check for 8 channels AES3 element */
3685 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3686 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3689 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3690 mxf->current_klv_data = (KLVPacket){{0}};
3693 } else if (mxf->eia608_extract &&
3694 s->streams[index]->codecpar->codec_id == AV_CODEC_ID_EIA_608) {
3695 ret = mxf_get_eia608_packet(s, s->streams[index], pkt, klv.length);
3697 mxf->current_klv_data = (KLVPacket){{0}};
3701 ret = av_get_packet(s->pb, pkt, klv.length);
3703 mxf->current_klv_data = (KLVPacket){{0}};
3707 pkt->stream_index = index;
3708 pkt->pos = klv.offset;
3710 ret = mxf_set_pts(mxf, st, pkt);
3712 mxf->current_klv_data = (KLVPacket){{0}};
3716 /* seek for truncated packets */
3717 avio_seek(s->pb, klv.next_klv, SEEK_SET);
3722 avio_skip(s->pb, max_data_size);
3723 mxf->current_klv_data = (KLVPacket){{0}};
3726 return avio_feof(s->pb) ? AVERROR_EOF : ret;
3729 static int mxf_read_close(AVFormatContext *s)
3731 MXFContext *mxf = s->priv_data;
3734 av_freep(&mxf->packages_refs);
3735 av_freep(&mxf->essence_container_data_refs);
3737 for (i = 0; i < s->nb_streams; i++)
3738 s->streams[i]->priv_data = NULL;
3740 for (i = 0; i < mxf->metadata_sets_count; i++) {
3741 mxf_free_metadataset(mxf->metadata_sets + i, 1);
3743 mxf->metadata_sets_count = 0;
3744 av_freep(&mxf->partitions);
3745 av_freep(&mxf->metadata_sets);
3746 av_freep(&mxf->aesc);
3747 av_freep(&mxf->local_tags);
3749 if (mxf->index_tables) {
3750 for (i = 0; i < mxf->nb_index_tables; i++) {
3751 av_freep(&mxf->index_tables[i].segments);
3752 av_freep(&mxf->index_tables[i].ptses);
3753 av_freep(&mxf->index_tables[i].fake_index);
3754 av_freep(&mxf->index_tables[i].offsets);
3757 av_freep(&mxf->index_tables);
3762 static int mxf_probe(const AVProbeData *p) {
3763 const uint8_t *bufp = p->buf;
3764 const uint8_t *end = p->buf + p->buf_size;
3766 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3769 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3770 end -= sizeof(mxf_header_partition_pack_key);
3772 for (; bufp < end;) {
3773 if (!((bufp[13] - 1) & 0xF2)){
3774 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3775 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3776 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3777 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3778 return bufp == p->buf ? AVPROBE_SCORE_MAX : AVPROBE_SCORE_MAX - 1;
3787 /* rudimentary byte seek */
3788 /* XXX: use MXF Index */
3789 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3791 AVStream *st = s->streams[stream_index];
3793 MXFContext* mxf = s->priv_data;
3797 MXFTrack *source_track = st->priv_data;
3802 /* if audio then truncate sample_time to EditRate */
3803 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3804 sample_time = av_rescale_q(sample_time, st->time_base,
3805 av_inv_q(source_track->edit_rate));
3807 if (mxf->nb_index_tables <= 0) {
3809 return AVERROR_INVALIDDATA;
3810 if (sample_time < 0)
3812 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3814 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3818 ff_update_cur_dts(s, st, sample_time);
3819 mxf->current_klv_data = (KLVPacket){{0}};
3821 MXFPartition *partition;
3823 t = &mxf->index_tables[0];
3824 if (t->index_sid != source_track->index_sid) {
3825 /* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
3826 for (i = 0; i < s->nb_streams; i++) {
3827 MXFTrack *new_source_track = s->streams[i]->priv_data;
3828 if (new_source_track && new_source_track->index_sid == t->index_sid) {
3829 sample_time = av_rescale_q(sample_time, new_source_track->edit_rate, source_track->edit_rate);
3830 source_track = new_source_track;
3835 if (i == s->nb_streams)
3836 return AVERROR_INVALIDDATA;
3839 /* clamp above zero, else ff_index_search_timestamp() returns negative
3840 * this also means we allow seeking before the start */
3841 sample_time = FFMAX(sample_time, 0);
3843 if (t->fake_index) {
3844 /* The first frames may not be keyframes in presentation order, so
3845 * we have to advance the target to be able to find the first
3846 * keyframe backwards... */
3847 if (!(flags & AVSEEK_FLAG_ANY) &&
3848 (flags & AVSEEK_FLAG_BACKWARD) &&
3849 t->ptses[0] != AV_NOPTS_VALUE &&
3850 sample_time < t->ptses[0] &&
3851 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3852 sample_time = t->ptses[0];
3854 /* behave as if we have a proper index */
3855 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3857 /* get the stored order index from the display order index */
3858 sample_time += t->offsets[sample_time];
3860 /* no IndexEntryArray (one or more CBR segments)
3861 * make sure we don't seek past the end */
3862 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3865 if (source_track->wrapping == UnknownWrapped)
3866 av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
3868 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
3871 ff_update_cur_dts(s, st, sample_time);
3872 if (source_track->wrapping == ClipWrapped) {
3873 KLVPacket klv = partition->first_essence_klv;
3874 if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
3875 av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
3876 return AVERROR_INVALIDDATA;
3878 mxf->current_klv_data = klv;
3880 mxf->current_klv_data = (KLVPacket){{0}};
3882 avio_seek(s->pb, seekpos, SEEK_SET);
3885 // Update all tracks sample count
3886 for (i = 0; i < s->nb_streams; i++) {
3887 AVStream *cur_st = s->streams[i];
3888 MXFTrack *cur_track = cur_st->priv_data;
3890 int64_t track_edit_unit = sample_time;
3892 mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
3893 cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
3899 static const AVOption options[] = {
3900 { "eia608_extract", "extract eia 608 captions from s436m track",
3901 offsetof(MXFContext, eia608_extract), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
3902 AV_OPT_FLAG_DECODING_PARAM },
3906 static const AVClass demuxer_class = {
3907 .class_name = "mxf",
3908 .item_name = av_default_item_name,
3910 .version = LIBAVUTIL_VERSION_INT,
3911 .category = AV_CLASS_CATEGORY_DEMUXER,
3914 const AVInputFormat ff_mxf_demuxer = {
3916 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3917 .flags = AVFMT_SEEK_TO_PTS,
3918 .priv_data_size = sizeof(MXFContext),
3919 .read_probe = mxf_probe,
3920 .read_header = mxf_read_header,
3921 .read_packet = mxf_read_packet,
3922 .read_close = mxf_read_close,
3923 .read_seek = mxf_read_seek,
3924 .priv_class = &demuxer_class,