3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * SMPTE 336M KLV Data Encoding Protocol Using Key-Length-Value
25 * SMPTE 377M MXF File Format Specifications
26 * SMPTE 378M Operational Pattern 1a
27 * SMPTE 379M MXF Generic Container
28 * SMPTE 381M Mapping MPEG Streams into the MXF Generic Container
29 * SMPTE 382M Mapping AES3 and Broadcast Wave Audio into the MXF Generic Container
30 * SMPTE 383M Mapping DV-DIF Data to the MXF Generic Container
33 * Search for Track numbers which will identify essence element KLV packets.
34 * Search for SourcePackage which define tracks which contains Track numbers.
35 * Material Package contains tracks with reference to SourcePackage tracks.
36 * Search for Descriptors (Picture, Sound) which contains codec info and parameters.
37 * Assign Descriptors to correct Tracks.
39 * Metadata reading functions read Local Tags, get InstanceUID(0x3C0A) then add MetaDataSet to MXFContext.
40 * Metadata parsing resolves Strong References to objects.
42 * Simple demuxer, only OP1A supported and some files might not work at all.
43 * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1
48 #include "libavutil/aes.h"
49 #include "libavutil/avassert.h"
50 #include "libavutil/mathematics.h"
51 #include "libavcodec/bytestream.h"
52 #include "libavutil/intreadwrite.h"
53 #include "libavutil/parseutils.h"
54 #include "libavutil/timecode.h"
76 OPSONYOpt, /* FATE sample, violates the spec in places */
79 typedef struct MXFPartition {
82 MXFPartitionType type;
83 uint64_t previous_partition;
86 int64_t this_partition;
87 int64_t essence_offset; ///< absolute offset of essence
88 int64_t essence_length;
90 int64_t header_byte_count;
91 int64_t index_byte_count;
93 int64_t pack_ofs; ///< absolute offset of pack in file, including run-in
96 typedef struct MXFCryptoContext {
98 enum MXFMetadataSetType type;
99 UID source_container_ul;
102 typedef struct MXFStructuralComponent {
104 enum MXFMetadataSetType type;
105 UID source_package_ul;
106 UID source_package_uid;
107 UID data_definition_ul;
109 int64_t start_position;
111 } MXFStructuralComponent;
113 typedef struct MXFSequence {
115 enum MXFMetadataSetType type;
116 UID data_definition_ul;
117 UID *structural_components_refs;
118 int structural_components_count;
123 typedef struct MXFTrack {
125 enum MXFMetadataSetType type;
128 struct AVRational rate;
130 } MXFTimecodeComponent;
134 enum MXFMetadataSetType type;
135 UID input_segment_ref;
136 } MXFPulldownComponent;
140 enum MXFMetadataSetType type;
141 UID *structural_components_refs;
142 int structural_components_count;
148 enum MXFMetadataSetType type;
155 enum MXFMetadataSetType type;
156 MXFSequence *sequence; /* mandatory, and only one */
160 uint8_t track_number[4];
161 AVRational edit_rate;
163 uint64_t sample_count;
164 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
167 typedef struct MXFDescriptor {
169 enum MXFMetadataSetType type;
170 UID essence_container_ul;
171 UID essence_codec_ul;
173 AVRational sample_rate;
174 AVRational aspect_ratio;
176 int height; /* Field height, not frame height */
177 int frame_layout; /* See MXFFrameLayout enum */
178 int video_line_map[2];
179 #define MXF_FIELD_DOMINANCE_DEFAULT 0
180 #define MXF_FIELD_DOMINANCE_FF 1 /* coded first, displayed first */
181 #define MXF_FIELD_DOMINANCE_FL 2 /* coded first, displayed last */
185 int64_t duration; /* ContainerDuration optional property */
186 unsigned int component_depth;
187 unsigned int horiz_subsampling;
188 unsigned int vert_subsampling;
189 UID *sub_descriptors_refs;
190 int sub_descriptors_count;
194 enum AVPixelFormat pix_fmt;
197 typedef struct MXFIndexTableSegment {
199 enum MXFMetadataSetType type;
200 int edit_unit_byte_count;
203 AVRational index_edit_rate;
204 uint64_t index_start_position;
205 uint64_t index_duration;
206 int8_t *temporal_offset_entries;
208 uint64_t *stream_offset_entries;
209 int nb_index_entries;
210 } MXFIndexTableSegment;
212 typedef struct MXFPackage {
214 enum MXFMetadataSetType type;
219 MXFDescriptor *descriptor; /* only one */
226 typedef struct MXFMetadataSet {
228 enum MXFMetadataSetType type;
231 /* decoded index table */
232 typedef struct MXFIndexTable {
235 int nb_ptses; /* number of PTSes or total duration of index */
236 int64_t first_dts; /* DTS = EditUnit + first_dts */
237 int64_t *ptses; /* maps EditUnit -> PTS */
239 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
240 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
241 int8_t *offsets; /* temporal offsets for display order to stored order conversion */
244 typedef struct MXFContext {
245 MXFPartition *partitions;
246 unsigned partitions_count;
250 MXFMetadataSet **metadata_sets;
251 int metadata_sets_count;
255 int local_tags_count;
256 uint64_t footer_partition;
257 KLVPacket current_klv_data;
258 int current_klv_index;
260 MXFPartition *current_partition;
261 int parsing_backward;
262 int64_t last_forward_tell;
263 int last_forward_partition;
264 int current_edit_unit;
266 MXFIndexTable *index_tables;
267 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
270 enum MXFWrappingScheme {
275 /* NOTE: klv_offset is not set (-1) for local keys */
276 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
278 typedef struct MXFMetadataReadTableEntry {
280 MXFMetadataReadFunc *read;
282 enum MXFMetadataSetType type;
283 } MXFMetadataReadTableEntry;
285 static int mxf_read_close(AVFormatContext *s);
287 /* partial keys to match */
288 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
289 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
290 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
291 static const uint8_t mxf_canopus_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x0a,0x0e,0x0f,0x03,0x01 };
292 static const uint8_t mxf_system_item_key_cp[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
293 static const uint8_t mxf_system_item_key_gc[] = { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x03,0x01,0x14 };
294 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
295 /* complete keys to match */
296 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 };
297 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
298 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
299 static const uint8_t mxf_random_index_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x11,0x01,0x00 };
300 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
301 static const uint8_t mxf_avid_project_name[] = { 0xa5,0xfb,0x7b,0x25,0xf6,0x15,0x94,0xb9,0x62,0xfc,0x37,0x17,0x49,0x2d,0x42,0xbf };
302 static const uint8_t mxf_jp2k_rsiz[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 };
303 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 };
304 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 };
306 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
308 static void mxf_free_metadataset(MXFMetadataSet **ctx, int freectx)
310 MXFIndexTableSegment *seg;
311 switch ((*ctx)->type) {
313 av_freep(&((MXFDescriptor *)*ctx)->extradata);
315 case MultipleDescriptor:
316 av_freep(&((MXFDescriptor *)*ctx)->sub_descriptors_refs);
319 av_freep(&((MXFSequence *)*ctx)->structural_components_refs);
322 av_freep(&((MXFEssenceGroup *)*ctx)->structural_components_refs);
325 case MaterialPackage:
326 av_freep(&((MXFPackage *)*ctx)->tracks_refs);
327 av_freep(&((MXFPackage *)*ctx)->name);
328 av_freep(&((MXFPackage *)*ctx)->comment_refs);
331 av_freep(&((MXFTaggedValue *)*ctx)->name);
332 av_freep(&((MXFTaggedValue *)*ctx)->value);
335 av_freep(&((MXFTrack *)*ctx)->name);
337 case IndexTableSegment:
338 seg = (MXFIndexTableSegment *)*ctx;
339 av_freep(&seg->temporal_offset_entries);
340 av_freep(&seg->flag_entries);
341 av_freep(&seg->stream_offset_entries);
349 static int64_t klv_decode_ber_length(AVIOContext *pb)
351 uint64_t size = avio_r8(pb);
352 if (size & 0x80) { /* long form */
353 int bytes_num = size & 0x7f;
354 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
356 return AVERROR_INVALIDDATA;
359 size = size << 8 | avio_r8(pb);
364 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
367 for (i = 0; i < size && !avio_feof(pb); i++) {
371 else if (b != key[i])
377 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
379 if (!mxf_read_sync(pb, mxf_klv_key, 4))
380 return AVERROR_INVALIDDATA;
381 klv->offset = avio_tell(pb) - 4;
382 memcpy(klv->key, mxf_klv_key, 4);
383 avio_read(pb, klv->key + 4, 12);
384 klv->length = klv_decode_ber_length(pb);
385 return klv->length == -1 ? -1 : 0;
388 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
392 for (i = 0; i < s->nb_streams; i++) {
393 MXFTrack *track = s->streams[i]->priv_data;
395 if (track && !memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
398 /* return 0 if only one stream, for OP Atom files with 0 as track number */
399 return s->nb_streams == 1 ? 0 : -1;
402 /* XXX: use AVBitStreamFilter */
403 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
405 const uint8_t *buf_ptr, *end_ptr;
409 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
410 return AVERROR_INVALIDDATA;
411 length = av_get_packet(pb, pkt, length);
414 data_ptr = pkt->data;
415 end_ptr = pkt->data + length;
416 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
417 for (; end_ptr - buf_ptr >= st->codecpar->channels * 4; ) {
418 for (i = 0; i < st->codecpar->channels; i++) {
419 uint32_t sample = bytestream_get_le32(&buf_ptr);
420 if (st->codecpar->bits_per_coded_sample == 24)
421 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
423 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
425 buf_ptr += 32 - st->codecpar->channels*4; // always 8 channels stored SMPTE 331M
427 av_shrink_packet(pkt, data_ptr - pkt->data);
431 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
433 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
434 MXFContext *mxf = s->priv_data;
435 AVIOContext *pb = s->pb;
436 int64_t end = avio_tell(pb) + klv->length;
439 uint64_t plaintext_size;
444 if (!mxf->aesc && s->key && s->keylen == 16) {
445 mxf->aesc = av_aes_alloc();
447 return AVERROR(ENOMEM);
448 av_aes_init(mxf->aesc, s->key, 128, 1);
451 avio_skip(pb, klv_decode_ber_length(pb));
453 klv_decode_ber_length(pb);
454 plaintext_size = avio_rb64(pb);
456 klv_decode_ber_length(pb);
457 avio_read(pb, klv->key, 16);
458 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
459 return AVERROR_INVALIDDATA;
460 index = mxf_get_stream_index(s, klv);
462 return AVERROR_INVALIDDATA;
464 klv_decode_ber_length(pb);
465 orig_size = avio_rb64(pb);
466 if (orig_size < plaintext_size)
467 return AVERROR_INVALIDDATA;
469 size = klv_decode_ber_length(pb);
470 if (size < 32 || size - 32 < orig_size)
471 return AVERROR_INVALIDDATA;
472 avio_read(pb, ivec, 16);
473 avio_read(pb, tmpbuf, 16);
475 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
476 if (memcmp(tmpbuf, checkv, 16))
477 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
479 size = av_get_packet(pb, pkt, size);
482 else if (size < plaintext_size)
483 return AVERROR_INVALIDDATA;
484 size -= plaintext_size;
486 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
487 &pkt->data[plaintext_size], size >> 4, ivec, 1);
488 av_shrink_packet(pkt, orig_size);
489 pkt->stream_index = index;
490 avio_skip(pb, end - avio_tell(pb));
494 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
496 MXFContext *mxf = arg;
497 int item_num = avio_rb32(pb);
498 int item_len = avio_rb32(pb);
500 if (item_len != 18) {
501 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
502 return AVERROR_PATCHWELCOME;
504 if (item_num > 65536 || item_num < 0) {
505 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
506 return AVERROR_INVALIDDATA;
509 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple primer packs\n");
510 av_free(mxf->local_tags);
511 mxf->local_tags_count = 0;
512 mxf->local_tags = av_calloc(item_num, item_len);
513 if (!mxf->local_tags)
514 return AVERROR(ENOMEM);
515 mxf->local_tags_count = item_num;
516 avio_read(pb, mxf->local_tags, item_num*item_len);
520 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
522 MXFContext *mxf = arg;
523 MXFPartition *partition, *tmp_part;
525 uint64_t footer_partition;
526 uint32_t nb_essence_containers;
528 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
530 return AVERROR(ENOMEM);
531 mxf->partitions = tmp_part;
533 if (mxf->parsing_backward) {
534 /* insert the new partition pack in the middle
535 * this makes the entries in mxf->partitions sorted by offset */
536 memmove(&mxf->partitions[mxf->last_forward_partition+1],
537 &mxf->partitions[mxf->last_forward_partition],
538 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
539 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
541 mxf->last_forward_partition++;
542 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
545 memset(partition, 0, sizeof(*partition));
546 mxf->partitions_count++;
547 partition->pack_length = avio_tell(pb) - klv_offset + size;
548 partition->pack_ofs = klv_offset;
552 partition->type = Header;
555 partition->type = BodyPartition;
558 partition->type = Footer;
561 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
562 return AVERROR_INVALIDDATA;
565 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
566 partition->closed = partition->type == Footer || !(uid[14] & 1);
567 partition->complete = uid[14] > 2;
569 partition->kag_size = avio_rb32(pb);
570 partition->this_partition = avio_rb64(pb);
571 partition->previous_partition = avio_rb64(pb);
572 footer_partition = avio_rb64(pb);
573 partition->header_byte_count = avio_rb64(pb);
574 partition->index_byte_count = avio_rb64(pb);
575 partition->index_sid = avio_rb32(pb);
577 partition->body_sid = avio_rb32(pb);
578 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
579 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
580 return AVERROR_INVALIDDATA;
582 nb_essence_containers = avio_rb32(pb);
584 if (partition->this_partition &&
585 partition->previous_partition == partition->this_partition) {
586 av_log(mxf->fc, AV_LOG_ERROR,
587 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
588 partition->previous_partition);
589 /* override with the actual previous partition offset */
590 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
592 mxf->partitions + mxf->last_forward_partition - 2;
593 partition->previous_partition = prev->this_partition;
595 /* if no previous body partition are found point to the header
597 if (partition->previous_partition == partition->this_partition)
598 partition->previous_partition = 0;
599 av_log(mxf->fc, AV_LOG_ERROR,
600 "Overriding PreviousPartition with %"PRIx64"\n",
601 partition->previous_partition);
604 /* some files don't have FooterPartition set in every partition */
605 if (footer_partition) {
606 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
607 av_log(mxf->fc, AV_LOG_ERROR,
608 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
609 mxf->footer_partition, footer_partition);
611 mxf->footer_partition = footer_partition;
615 av_log(mxf->fc, AV_LOG_TRACE,
616 "PartitionPack: ThisPartition = 0x%"PRIX64
617 ", PreviousPartition = 0x%"PRIX64", "
618 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
619 partition->this_partition,
620 partition->previous_partition, footer_partition,
621 partition->index_sid, partition->body_sid);
623 /* sanity check PreviousPartition if set */
624 //NOTE: this isn't actually enough, see mxf_seek_to_previous_partition()
625 if (partition->previous_partition &&
626 mxf->run_in + partition->previous_partition >= klv_offset) {
627 av_log(mxf->fc, AV_LOG_ERROR,
628 "PreviousPartition points to this partition or forward\n");
629 return AVERROR_INVALIDDATA;
632 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
633 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
634 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
635 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
636 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
637 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
638 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
639 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
640 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
641 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
642 else if (op[12] == 0x10) {
643 /* SMPTE 390m: "There shall be exactly one essence container"
644 * The following block deals with files that violate this, namely:
645 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
646 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
647 if (nb_essence_containers != 1) {
648 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
652 av_log(mxf->fc, AV_LOG_WARNING,
653 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
654 nb_essence_containers,
655 op == OP1a ? "OP1a" : "OPAtom");
661 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
665 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
666 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
667 partition->kag_size);
669 if (mxf->op == OPSONYOpt)
670 partition->kag_size = 512;
672 partition->kag_size = 1;
674 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
680 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
682 MXFMetadataSet **tmp;
684 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
686 return AVERROR(ENOMEM);
687 mxf->metadata_sets = tmp;
688 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
689 mxf->metadata_sets_count++;
693 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
695 MXFCryptoContext *cryptocontext = arg;
697 return AVERROR_INVALIDDATA;
698 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
699 avio_read(pb, cryptocontext->source_container_ul, 16);
703 static int mxf_read_strong_ref_array(AVIOContext *pb, UID **refs, int *count)
705 *count = avio_rb32(pb);
706 *refs = av_calloc(*count, sizeof(UID));
709 return AVERROR(ENOMEM);
711 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
712 avio_read(pb, (uint8_t *)*refs, *count * sizeof(UID));
716 static inline int mxf_read_utf16_string(AVIOContext *pb, int size, char** str, int be)
721 if (size < 0 || size > INT_MAX/2)
722 return AVERROR(EINVAL);
724 buf_size = size + size / 2 + 1;
725 *str = av_malloc(buf_size);
727 return AVERROR(ENOMEM);
730 ret = avio_get_str16be(pb, size, *str, buf_size);
732 ret = avio_get_str16le(pb, size, *str, buf_size);
742 #define READ_STR16(type, big_endian) \
743 static int mxf_read_utf16 ## type ##_string(AVIOContext *pb, int size, char** str) \
745 return mxf_read_utf16_string(pb, size, str, big_endian); \
751 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
753 MXFContext *mxf = arg;
756 if (mxf->packages_refs)
757 av_log(mxf->fc, AV_LOG_VERBOSE, "Multiple packages_refs\n");
758 av_free(mxf->packages_refs);
759 return mxf_read_strong_ref_array(pb, &mxf->packages_refs, &mxf->packages_count);
764 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
766 MXFStructuralComponent *source_clip = arg;
769 source_clip->duration = avio_rb64(pb);
772 source_clip->start_position = avio_rb64(pb);
775 /* UMID, only get last 16 bytes */
776 avio_read(pb, source_clip->source_package_ul, 16);
777 avio_read(pb, source_clip->source_package_uid, 16);
780 source_clip->source_track_id = avio_rb32(pb);
786 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
788 MXFTimecodeComponent *mxf_timecode = arg;
791 mxf_timecode->start_frame = avio_rb64(pb);
794 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
797 mxf_timecode->drop_frame = avio_r8(pb);
803 static int mxf_read_pulldown_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
805 MXFPulldownComponent *mxf_pulldown = arg;
808 avio_read(pb, mxf_pulldown->input_segment_ref, 16);
814 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
816 MXFTrack *track = arg;
819 track->track_id = avio_rb32(pb);
822 avio_read(pb, track->track_number, 4);
825 mxf_read_utf16be_string(pb, size, &track->name);
828 track->edit_rate.num = avio_rb32(pb);
829 track->edit_rate.den = avio_rb32(pb);
832 avio_read(pb, track->sequence_ref, 16);
838 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
840 MXFSequence *sequence = arg;
843 sequence->duration = avio_rb64(pb);
846 avio_read(pb, sequence->data_definition_ul, 16);
849 sequence->origin = avio_r8(pb);
852 return mxf_read_strong_ref_array(pb, &sequence->structural_components_refs,
853 &sequence->structural_components_count);
858 static int mxf_read_essence_group(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
860 MXFEssenceGroup *essence_group = arg;
863 essence_group->duration = avio_rb64(pb);
866 return mxf_read_strong_ref_array(pb, &essence_group->structural_components_refs,
867 &essence_group->structural_components_count);
872 static int mxf_read_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
874 MXFPackage *package = arg;
877 return mxf_read_strong_ref_array(pb, &package->tracks_refs,
878 &package->tracks_count);
881 avio_read(pb, package->package_ul, 16);
882 avio_read(pb, package->package_uid, 16);
885 avio_read(pb, package->descriptor_ref, 16);
888 return mxf_read_utf16be_string(pb, size, &package->name);
890 return mxf_read_strong_ref_array(pb, &package->comment_refs,
891 &package->comment_count);
896 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
900 segment->nb_index_entries = avio_rb32(pb);
902 length = avio_rb32(pb);
903 if(segment->nb_index_entries && length < 11)
904 return AVERROR_INVALIDDATA;
906 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
907 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
908 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries)))) {
909 av_freep(&segment->temporal_offset_entries);
910 av_freep(&segment->flag_entries);
911 return AVERROR(ENOMEM);
914 for (i = 0; i < segment->nb_index_entries; i++) {
916 return AVERROR_INVALIDDATA;
917 segment->temporal_offset_entries[i] = avio_r8(pb);
918 avio_r8(pb); /* KeyFrameOffset */
919 segment->flag_entries[i] = avio_r8(pb);
920 segment->stream_offset_entries[i] = avio_rb64(pb);
921 avio_skip(pb, length - 11);
926 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
928 MXFIndexTableSegment *segment = arg;
931 segment->edit_unit_byte_count = avio_rb32(pb);
932 av_log(NULL, AV_LOG_TRACE, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
935 segment->index_sid = avio_rb32(pb);
936 av_log(NULL, AV_LOG_TRACE, "IndexSID %d\n", segment->index_sid);
939 segment->body_sid = avio_rb32(pb);
940 av_log(NULL, AV_LOG_TRACE, "BodySID %d\n", segment->body_sid);
943 av_log(NULL, AV_LOG_TRACE, "IndexEntryArray found\n");
944 return mxf_read_index_entry_array(pb, segment);
946 segment->index_edit_rate.num = avio_rb32(pb);
947 segment->index_edit_rate.den = avio_rb32(pb);
948 av_log(NULL, AV_LOG_TRACE, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
949 segment->index_edit_rate.den);
952 segment->index_start_position = avio_rb64(pb);
953 av_log(NULL, AV_LOG_TRACE, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
956 segment->index_duration = avio_rb64(pb);
957 av_log(NULL, AV_LOG_TRACE, "IndexDuration %"PRId64"\n", segment->index_duration);
963 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
965 int code, value, ofs = 0;
966 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
971 av_log(NULL, AV_LOG_TRACE, "pixel layout: code %#x\n", code);
974 layout[ofs++] = code;
975 layout[ofs++] = value;
977 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
978 } while (code != 0); /* SMPTE 377M E.2.46 */
980 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
983 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
985 MXFDescriptor *descriptor = arg;
986 int entry_count, entry_size;
990 return mxf_read_strong_ref_array(pb, &descriptor->sub_descriptors_refs,
991 &descriptor->sub_descriptors_count);
992 case 0x3002: /* ContainerDuration */
993 descriptor->duration = avio_rb64(pb);
996 avio_read(pb, descriptor->essence_container_ul, 16);
999 avio_read(pb, descriptor->codec_ul, 16);
1002 descriptor->linked_track_id = avio_rb32(pb);
1004 case 0x3201: /* PictureEssenceCoding */
1005 avio_read(pb, descriptor->essence_codec_ul, 16);
1008 descriptor->width = avio_rb32(pb);
1011 descriptor->height = avio_rb32(pb);
1014 descriptor->frame_layout = avio_r8(pb);
1017 entry_count = avio_rb32(pb);
1018 entry_size = avio_rb32(pb);
1019 if (entry_size == 4) {
1020 if (entry_count > 0)
1021 descriptor->video_line_map[0] = avio_rb32(pb);
1023 descriptor->video_line_map[0] = 0;
1024 if (entry_count > 1)
1025 descriptor->video_line_map[1] = avio_rb32(pb);
1027 descriptor->video_line_map[1] = 0;
1029 av_log(NULL, AV_LOG_WARNING, "VideoLineMap element size %d currently not supported\n", entry_size);
1032 descriptor->aspect_ratio.num = avio_rb32(pb);
1033 descriptor->aspect_ratio.den = avio_rb32(pb);
1036 descriptor->field_dominance = avio_r8(pb);
1039 descriptor->component_depth = avio_rb32(pb);
1042 descriptor->horiz_subsampling = avio_rb32(pb);
1045 descriptor->vert_subsampling = avio_rb32(pb);
1048 descriptor->sample_rate.num = avio_rb32(pb);
1049 descriptor->sample_rate.den = avio_rb32(pb);
1051 case 0x3D06: /* SoundEssenceCompression */
1052 avio_read(pb, descriptor->essence_codec_ul, 16);
1055 descriptor->channels = avio_rb32(pb);
1058 descriptor->bits_per_sample = avio_rb32(pb);
1061 mxf_read_pixel_layout(pb, descriptor);
1064 /* Private uid used by SONY C0023S01.mxf */
1065 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
1066 if (descriptor->extradata)
1067 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
1068 av_free(descriptor->extradata);
1069 descriptor->extradata_size = 0;
1070 descriptor->extradata = av_malloc(size);
1071 if (!descriptor->extradata)
1072 return AVERROR(ENOMEM);
1073 descriptor->extradata_size = size;
1074 avio_read(pb, descriptor->extradata, size);
1076 if (IS_KLV_KEY(uid, mxf_jp2k_rsiz)) {
1077 uint32_t rsiz = avio_rb16(pb);
1078 if (rsiz == FF_PROFILE_JPEG2000_DCINEMA_2K ||
1079 rsiz == FF_PROFILE_JPEG2000_DCINEMA_4K)
1080 descriptor->pix_fmt = AV_PIX_FMT_XYZ12;
1087 static int mxf_read_indirect_value(void *arg, AVIOContext *pb, int size)
1089 MXFTaggedValue *tagged_value = arg;
1095 avio_read(pb, key, 17);
1096 /* TODO: handle other types of of indirect values */
1097 if (memcmp(key, mxf_indirect_value_utf16le, 17) == 0) {
1098 return mxf_read_utf16le_string(pb, size - 17, &tagged_value->value);
1099 } else if (memcmp(key, mxf_indirect_value_utf16be, 17) == 0) {
1100 return mxf_read_utf16be_string(pb, size - 17, &tagged_value->value);
1105 static int mxf_read_tagged_value(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
1107 MXFTaggedValue *tagged_value = arg;
1110 return mxf_read_utf16be_string(pb, size, &tagged_value->name);
1112 return mxf_read_indirect_value(tagged_value, pb, size);
1118 * Match an uid independently of the version byte and up to len common bytes
1121 static int mxf_match_uid(const UID key, const UID uid, int len)
1124 for (i = 0; i < len; i++) {
1125 if (i != 7 && key[i] != uid[i])
1131 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
1133 while (uls->uid[0]) {
1134 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
1141 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
1147 for (i = 0; i < mxf->metadata_sets_count; i++) {
1148 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
1149 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
1150 return mxf->metadata_sets[i];
1156 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
1157 // video essence container uls
1158 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0c,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 },
1159 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x10,0x60,0x01 }, 14, AV_CODEC_ID_H264 }, /* H.264 frame wrapped */
1160 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x12,0x01,0x00 }, 14, AV_CODEC_ID_VC1 }, /* VC-1 frame wrapped */
1161 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* MPEG-ES frame wrapped */
1162 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x04,0x01 }, 14, AV_CODEC_ID_MPEG2VIDEO }, /* Type D-10 mapping of 40Mbps 525/60-I */
1163 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
1164 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* uncompressed picture */
1165 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x01,0x01 }, 15, AV_CODEC_ID_HQ_HQA },
1166 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0a,0x0e,0x0f,0x03,0x01,0x02,0x20,0x02,0x01 }, 15, AV_CODEC_ID_HQX },
1167 { { 0x06,0x0e,0x2b,0x34,0x01,0x01,0x01,0xff,0x4b,0x46,0x41,0x41,0x00,0x0d,0x4d,0x4f }, 14, AV_CODEC_ID_RAWVIDEO }, /* Legacy ?? Uncompressed Picture */
1168 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1171 /* EC ULs for intra-only formats */
1172 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
1173 { { 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 */
1174 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1177 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
1178 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
1179 { { 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 */
1180 { { 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 */
1181 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1184 /* actual coded width for AVC-Intra to allow selecting correct SPS/PPS */
1185 static const MXFCodecUL mxf_intra_only_picture_coded_width[] = {
1186 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x01 }, 16, 1440 },
1187 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x02 }, 16, 1440 },
1188 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x03 }, 16, 1440 },
1189 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x0A,0x04,0x01,0x02,0x02,0x01,0x32,0x21,0x04 }, 16, 1440 },
1190 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, 0 },
1193 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
1194 // sound essence container uls
1195 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, AV_CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */
1196 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x02,0x0d,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, AV_CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */
1197 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, AV_CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */
1198 { { 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 */
1199 { { 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) */
1200 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1203 static const MXFCodecUL mxf_data_essence_container_uls[] = {
1204 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
1205 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
1208 static const char * const mxf_data_essence_descriptor[] = {
1209 "vbi_vanc_smpte_436M",
1212 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1214 int i, j, nb_segments = 0;
1215 MXFIndexTableSegment **unsorted_segments;
1216 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1218 /* count number of segments, allocate arrays and copy unsorted segments */
1219 for (i = 0; i < mxf->metadata_sets_count; i++)
1220 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1224 return AVERROR_INVALIDDATA;
1226 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1227 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1228 av_freep(sorted_segments);
1229 av_free(unsorted_segments);
1230 return AVERROR(ENOMEM);
1233 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1234 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1235 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1237 *nb_sorted_segments = 0;
1239 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1240 for (i = 0; i < nb_segments; i++) {
1241 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1242 uint64_t best_index_duration = 0;
1244 for (j = 0; j < nb_segments; j++) {
1245 MXFIndexTableSegment *s = unsorted_segments[j];
1247 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1248 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1249 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1251 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1252 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1253 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1255 best_body_sid = s->body_sid;
1256 best_index_sid = s->index_sid;
1257 best_index_start = s->index_start_position;
1258 best_index_duration = s->index_duration;
1262 /* no suitable entry found -> we're done */
1266 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1267 last_body_sid = best_body_sid;
1268 last_index_sid = best_index_sid;
1269 last_index_start = best_index_start;
1272 av_free(unsorted_segments);
1278 * Computes the absolute file offset of the given essence container offset
1280 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1283 int64_t offset_in = offset; /* for logging */
1285 for (x = 0; x < mxf->partitions_count; x++) {
1286 MXFPartition *p = &mxf->partitions[x];
1288 if (p->body_sid != body_sid)
1291 if (offset < p->essence_length || !p->essence_length) {
1292 *offset_out = p->essence_offset + offset;
1296 offset -= p->essence_length;
1299 av_log(mxf->fc, AV_LOG_ERROR,
1300 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1301 offset_in, body_sid);
1303 return AVERROR_INVALIDDATA;
1307 * Returns the end position of the essence container with given BodySID, or zero if unknown
1309 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1314 for (x = 0; x < mxf->partitions_count; x++) {
1315 MXFPartition *p = &mxf->partitions[x];
1317 if (p->body_sid != body_sid)
1320 if (!p->essence_length)
1323 ret = p->essence_offset + p->essence_length;
1329 /* EditUnit -> absolute offset */
1330 static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, int64_t *edit_unit_out, int64_t *offset_out, int nag)
1333 int64_t offset_temp = 0;
1335 for (i = 0; i < index_table->nb_segments; i++) {
1336 MXFIndexTableSegment *s = index_table->segments[i];
1338 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1340 if (edit_unit < s->index_start_position + s->index_duration) {
1341 int64_t index = edit_unit - s->index_start_position;
1343 if (s->edit_unit_byte_count)
1344 offset_temp += s->edit_unit_byte_count * index;
1345 else if (s->nb_index_entries) {
1346 if (s->nb_index_entries == 2 * s->index_duration + 1)
1347 index *= 2; /* Avid index */
1349 if (index < 0 || index >= s->nb_index_entries) {
1350 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1351 index_table->index_sid, s->index_start_position);
1352 return AVERROR_INVALIDDATA;
1355 offset_temp = s->stream_offset_entries[index];
1357 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1358 index_table->index_sid, s->index_start_position);
1359 return AVERROR_INVALIDDATA;
1363 *edit_unit_out = edit_unit;
1365 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1367 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1368 offset_temp += s->edit_unit_byte_count * s->index_duration;
1373 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);
1375 return AVERROR_INVALIDDATA;
1378 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1381 int8_t max_temporal_offset = -128;
1384 /* first compute how many entries we have */
1385 for (i = 0; i < index_table->nb_segments; i++) {
1386 MXFIndexTableSegment *s = index_table->segments[i];
1388 if (!s->nb_index_entries) {
1389 index_table->nb_ptses = 0;
1390 return 0; /* no TemporalOffsets */
1393 index_table->nb_ptses += s->index_duration;
1396 /* paranoid check */
1397 if (index_table->nb_ptses <= 0)
1400 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1401 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry))) ||
1402 !(index_table->offsets = av_calloc(index_table->nb_ptses, sizeof(int8_t))) ||
1403 !(flags = av_calloc(index_table->nb_ptses, sizeof(uint8_t)))) {
1404 av_freep(&index_table->ptses);
1405 av_freep(&index_table->fake_index);
1406 av_freep(&index_table->offsets);
1407 return AVERROR(ENOMEM);
1410 /* we may have a few bad TemporalOffsets
1411 * make sure the corresponding PTSes don't have the bogus value 0 */
1412 for (x = 0; x < index_table->nb_ptses; x++)
1413 index_table->ptses[x] = AV_NOPTS_VALUE;
1427 * We want to transform it into this:
1438 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1439 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1440 * The latter makes DTS <= PTS.
1442 for (i = x = 0; i < index_table->nb_segments; i++) {
1443 MXFIndexTableSegment *s = index_table->segments[i];
1444 int index_delta = 1;
1445 int n = s->nb_index_entries;
1447 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1448 index_delta = 2; /* Avid index */
1449 /* ignore the last entry - it's the size of the essence container */
1453 for (j = 0; j < n; j += index_delta, x++) {
1454 int offset = s->temporal_offset_entries[j] / index_delta;
1455 int index = x + offset;
1457 if (x >= index_table->nb_ptses) {
1458 av_log(mxf->fc, AV_LOG_ERROR,
1459 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1460 s->nb_index_entries, s->index_duration);
1464 flags[x] = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1466 if (index < 0 || index >= index_table->nb_ptses) {
1467 av_log(mxf->fc, AV_LOG_ERROR,
1468 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1473 index_table->offsets[x] = offset;
1474 index_table->ptses[index] = x;
1475 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1479 /* calculate the fake index table in display order */
1480 for (x = 0; x < index_table->nb_ptses; x++) {
1481 index_table->fake_index[x].timestamp = x;
1482 if (index_table->ptses[x] != AV_NOPTS_VALUE)
1483 index_table->fake_index[index_table->ptses[x]].flags = flags[x];
1487 index_table->first_dts = -max_temporal_offset;
1493 * Sorts and collects index table segments into index tables.
1494 * Also computes PTSes if possible.
1496 static int mxf_compute_index_tables(MXFContext *mxf)
1498 int i, j, k, ret, nb_sorted_segments;
1499 MXFIndexTableSegment **sorted_segments = NULL;
1500 AVStream *st = NULL;
1502 for (i = 0; i < mxf->fc->nb_streams; i++) {
1503 if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
1505 st = mxf->fc->streams[i];
1509 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1510 nb_sorted_segments <= 0) {
1511 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1515 /* sanity check and count unique BodySIDs/IndexSIDs */
1516 for (i = 0; i < nb_sorted_segments; i++) {
1517 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1518 mxf->nb_index_tables++;
1519 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1520 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1521 ret = AVERROR_INVALIDDATA;
1522 goto finish_decoding_index;
1526 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1527 sizeof(*mxf->index_tables));
1528 if (!mxf->index_tables) {
1529 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1530 ret = AVERROR(ENOMEM);
1531 goto finish_decoding_index;
1534 /* distribute sorted segments to index tables */
1535 for (i = j = 0; i < nb_sorted_segments; i++) {
1536 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1541 mxf->index_tables[j].nb_segments++;
1544 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1545 MXFIndexTable *t = &mxf->index_tables[j];
1547 t->segments = av_mallocz_array(t->nb_segments,
1548 sizeof(*t->segments));
1551 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1552 " pointer array\n");
1553 ret = AVERROR(ENOMEM);
1554 goto finish_decoding_index;
1557 if (sorted_segments[i]->index_start_position)
1558 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1559 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1561 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1562 t->index_sid = sorted_segments[i]->index_sid;
1563 t->body_sid = sorted_segments[i]->body_sid;
1565 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1566 goto finish_decoding_index;
1568 /* fix zero IndexDurations */
1569 for (k = 0; k < t->nb_segments; k++) {
1570 if (t->segments[k]->index_duration)
1573 if (t->nb_segments > 1)
1574 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1578 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1582 /* assume the first stream's duration is reasonable
1583 * leave index_duration = 0 on further segments in case we have any (unlikely)
1585 t->segments[k]->index_duration = st->duration;
1591 finish_decoding_index:
1592 av_free(sorted_segments);
1596 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1598 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1599 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1600 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1601 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1604 static int mxf_uid_to_str(UID uid, char **str)
1608 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1610 return AVERROR(ENOMEM);
1611 for (i = 0; i < sizeof(UID); i++) {
1612 snprintf(p, 2 + 1, "%.2x", uid[i]);
1614 if (i == 3 || i == 5 || i == 7 || i == 9) {
1615 snprintf(p, 1 + 1, "-");
1622 static int mxf_umid_to_str(UID ul, UID uid, char **str)
1626 p = *str = av_mallocz(sizeof(UID) * 4 + 2 + 1);
1628 return AVERROR(ENOMEM);
1629 snprintf(p, 2 + 1, "0x");
1631 for (i = 0; i < sizeof(UID); i++) {
1632 snprintf(p, 2 + 1, "%.2X", ul[i]);
1636 for (i = 0; i < sizeof(UID); i++) {
1637 snprintf(p, 2 + 1, "%.2X", uid[i]);
1643 static int mxf_add_umid_metadata(AVDictionary **pm, const char *key, MXFPackage* package)
1649 if ((ret = mxf_umid_to_str(package->package_ul, package->package_uid, &str)) < 0)
1651 av_dict_set(pm, key, str, AV_DICT_DONT_STRDUP_VAL);
1655 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1657 char buf[AV_TIMECODE_STR_SIZE];
1658 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1663 static MXFTimecodeComponent* mxf_resolve_timecode_component(MXFContext *mxf, UID *strong_ref)
1665 MXFStructuralComponent *component = NULL;
1666 MXFPulldownComponent *pulldown = NULL;
1668 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1672 switch (component->type) {
1673 case TimecodeComponent:
1674 return (MXFTimecodeComponent*)component;
1675 case PulldownComponent: /* timcode component may be located on a pulldown component */
1676 pulldown = (MXFPulldownComponent*)component;
1677 return mxf_resolve_strong_ref(mxf, &pulldown->input_segment_ref, TimecodeComponent);
1684 static MXFPackage* mxf_resolve_source_package(MXFContext *mxf, UID package_ul, UID package_uid)
1686 MXFPackage *package = NULL;
1689 for (i = 0; i < mxf->packages_count; i++) {
1690 package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], SourcePackage);
1694 if (!memcmp(package->package_ul, package_ul, 16) && !memcmp(package->package_uid, package_uid, 16))
1700 static MXFDescriptor* mxf_resolve_multidescriptor(MXFContext *mxf, MXFDescriptor *descriptor, int track_id)
1702 MXFDescriptor *sub_descriptor = NULL;
1708 if (descriptor->type == MultipleDescriptor) {
1709 for (i = 0; i < descriptor->sub_descriptors_count; i++) {
1710 sub_descriptor = mxf_resolve_strong_ref(mxf, &descriptor->sub_descriptors_refs[i], Descriptor);
1712 if (!sub_descriptor) {
1713 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1716 if (sub_descriptor->linked_track_id == track_id) {
1717 return sub_descriptor;
1720 } else if (descriptor->type == Descriptor)
1726 static MXFStructuralComponent* mxf_resolve_essence_group_choice(MXFContext *mxf, MXFEssenceGroup *essence_group)
1728 MXFStructuralComponent *component = NULL;
1729 MXFPackage *package = NULL;
1730 MXFDescriptor *descriptor = NULL;
1733 if (!essence_group || !essence_group->structural_components_count)
1736 /* essence groups contains multiple representations of the same media,
1737 this return the first components with a valid Descriptor typically index 0 */
1738 for (i =0; i < essence_group->structural_components_count; i++){
1739 component = mxf_resolve_strong_ref(mxf, &essence_group->structural_components_refs[i], SourceClip);
1743 if (!(package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid)))
1746 descriptor = mxf_resolve_strong_ref(mxf, &package->descriptor_ref, Descriptor);
1753 static MXFStructuralComponent* mxf_resolve_sourceclip(MXFContext *mxf, UID *strong_ref)
1755 MXFStructuralComponent *component = NULL;
1757 component = mxf_resolve_strong_ref(mxf, strong_ref, AnyType);
1760 switch (component->type) {
1764 return mxf_resolve_essence_group_choice(mxf, (MXFEssenceGroup*) component);
1771 static int mxf_parse_package_comments(MXFContext *mxf, AVDictionary **pm, MXFPackage *package)
1773 MXFTaggedValue *tag;
1777 for (i = 0; i < package->comment_count; i++) {
1778 tag = mxf_resolve_strong_ref(mxf, &package->comment_refs[i], TaggedValue);
1779 if (!tag || !tag->name || !tag->value)
1782 size = strlen(tag->name) + 8 + 1;
1783 key = av_mallocz(size);
1785 return AVERROR(ENOMEM);
1787 snprintf(key, size, "comment_%s", tag->name);
1788 av_dict_set(pm, key, tag->value, AV_DICT_DONT_STRDUP_KEY);
1793 static int mxf_parse_physical_source_package(MXFContext *mxf, MXFTrack *source_track, AVStream *st)
1795 MXFPackage *physical_package = NULL;
1796 MXFTrack *physical_track = NULL;
1797 MXFStructuralComponent *sourceclip = NULL;
1798 MXFTimecodeComponent *mxf_tc = NULL;
1802 int64_t start_position;
1804 for (i = 0; i < source_track->sequence->structural_components_count; i++) {
1805 sourceclip = mxf_resolve_strong_ref(mxf, &source_track->sequence->structural_components_refs[i], SourceClip);
1809 if (!(physical_package = mxf_resolve_source_package(mxf, sourceclip->source_package_ul, sourceclip->source_package_uid)))
1812 mxf_add_umid_metadata(&st->metadata, "reel_umid", physical_package);
1814 /* the name of physical source package is name of the reel or tape */
1815 if (physical_package->name && physical_package->name[0])
1816 av_dict_set(&st->metadata, "reel_name", physical_package->name, 0);
1818 /* the source timecode is calculated by adding the start_position of the sourceclip from the file source package track
1819 * to the start_frame of the timecode component located on one of the tracks of the physical source package.
1821 for (j = 0; j < physical_package->tracks_count; j++) {
1822 if (!(physical_track = mxf_resolve_strong_ref(mxf, &physical_package->tracks_refs[j], Track))) {
1823 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1827 if (!(physical_track->sequence = mxf_resolve_strong_ref(mxf, &physical_track->sequence_ref, Sequence))) {
1828 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1832 if (physical_track->edit_rate.num <= 0 ||
1833 physical_track->edit_rate.den <= 0) {
1834 av_log(mxf->fc, AV_LOG_WARNING,
1835 "Invalid edit rate (%d/%d) found on structural"
1836 " component #%d, defaulting to 25/1\n",
1837 physical_track->edit_rate.num,
1838 physical_track->edit_rate.den, i);
1839 physical_track->edit_rate = (AVRational){25, 1};
1842 for (k = 0; k < physical_track->sequence->structural_components_count; k++) {
1843 if (!(mxf_tc = mxf_resolve_timecode_component(mxf, &physical_track->sequence->structural_components_refs[k])))
1846 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1847 /* scale sourceclip start_position to match physical track edit rate */
1848 start_position = av_rescale_q(sourceclip->start_position,
1849 physical_track->edit_rate,
1850 source_track->edit_rate);
1852 if (av_timecode_init(&tc, mxf_tc->rate, flags, start_position + mxf_tc->start_frame, mxf->fc) == 0) {
1853 mxf_add_timecode_metadata(&st->metadata, "timecode", &tc);
1863 static int mxf_add_metadata_stream(MXFContext *mxf, MXFTrack *track)
1865 MXFStructuralComponent *component = NULL;
1866 const MXFCodecUL *codec_ul = NULL;
1867 MXFPackage tmp_package;
1871 for (j = 0; j < track->sequence->structural_components_count; j++) {
1872 component = mxf_resolve_sourceclip(mxf, &track->sequence->structural_components_refs[j]);
1880 st = avformat_new_stream(mxf->fc, NULL);
1882 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate metadata stream\n");
1883 return AVERROR(ENOMEM);
1886 st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
1887 st->codecpar->codec_id = AV_CODEC_ID_NONE;
1888 st->id = track->track_id;
1890 memcpy(&tmp_package.package_ul, component->source_package_ul, 16);
1891 memcpy(&tmp_package.package_uid, component->source_package_uid, 16);
1892 mxf_add_umid_metadata(&st->metadata, "file_package_umid", &tmp_package);
1893 if (track->name && track->name[0])
1894 av_dict_set(&st->metadata, "track_name", track->name, 0);
1896 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &track->sequence->data_definition_ul);
1897 av_dict_set(&st->metadata, "data_type", av_get_media_type_string(codec_ul->id), 0);
1901 static int mxf_parse_structural_metadata(MXFContext *mxf)
1903 MXFPackage *material_package = NULL;
1906 av_log(mxf->fc, AV_LOG_TRACE, "metadata sets count %d\n", mxf->metadata_sets_count);
1907 /* TODO: handle multiple material packages (OP3x) */
1908 for (i = 0; i < mxf->packages_count; i++) {
1909 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1910 if (material_package) break;
1912 if (!material_package) {
1913 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1914 return AVERROR_INVALIDDATA;
1917 mxf_add_umid_metadata(&mxf->fc->metadata, "material_package_umid", material_package);
1918 if (material_package->name && material_package->name[0])
1919 av_dict_set(&mxf->fc->metadata, "material_package_name", material_package->name, 0);
1920 mxf_parse_package_comments(mxf, &mxf->fc->metadata, material_package);
1922 for (i = 0; i < material_package->tracks_count; i++) {
1923 MXFPackage *source_package = NULL;
1924 MXFTrack *material_track = NULL;
1925 MXFTrack *source_track = NULL;
1926 MXFTrack *temp_track = NULL;
1927 MXFDescriptor *descriptor = NULL;
1928 MXFStructuralComponent *component = NULL;
1929 MXFTimecodeComponent *mxf_tc = NULL;
1930 UID *essence_container_ul = NULL;
1931 const MXFCodecUL *codec_ul = NULL;
1932 const MXFCodecUL *container_ul = NULL;
1933 const MXFCodecUL *pix_fmt_ul = NULL;
1938 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1939 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1943 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1944 mxf_tc = (MXFTimecodeComponent*)component;
1945 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1946 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1947 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1951 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1952 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1956 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1957 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1961 mxf_tc = (MXFTimecodeComponent*)component;
1962 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1963 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1964 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1969 /* TODO: handle multiple source clips, only finds first valid source clip */
1970 if(material_track->sequence->structural_components_count > 1)
1971 av_log(mxf->fc, AV_LOG_WARNING, "material track %d: has %d components\n",
1972 material_track->track_id, material_track->sequence->structural_components_count);
1974 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1975 component = mxf_resolve_sourceclip(mxf, &material_track->sequence->structural_components_refs[j]);
1979 source_package = mxf_resolve_source_package(mxf, component->source_package_ul, component->source_package_uid);
1980 if (!source_package) {
1981 av_log(mxf->fc, AV_LOG_TRACE, "material track %d: no corresponding source package found\n", material_track->track_id);
1984 for (k = 0; k < source_package->tracks_count; k++) {
1985 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1986 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1987 ret = AVERROR_INVALIDDATA;
1990 if (temp_track->track_id == component->source_track_id) {
1991 source_track = temp_track;
1995 if (!source_track) {
1996 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1999 if(source_track && component)
2002 if (!source_track || !component || !source_package) {
2003 if((ret = mxf_add_metadata_stream(mxf, material_track)))
2008 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
2009 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
2010 ret = AVERROR_INVALIDDATA;
2014 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
2015 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
2016 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
2017 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
2021 st = avformat_new_stream(mxf->fc, NULL);
2023 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
2024 ret = AVERROR(ENOMEM);
2027 st->id = material_track->track_id;
2028 st->priv_data = source_track;
2030 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
2031 descriptor = mxf_resolve_multidescriptor(mxf, source_package->descriptor, source_track->track_id);
2033 /* A SourceClip from a EssenceGroup may only be a single frame of essence data. The clips duration is then how many
2034 * frames its suppose to repeat for. Descriptor->duration, if present, contains the real duration of the essence data */
2035 if (descriptor && descriptor->duration != AV_NOPTS_VALUE)
2036 source_track->original_duration = st->duration = FFMIN(descriptor->duration, component->duration);
2038 source_track->original_duration = st->duration = component->duration;
2040 if (st->duration == -1)
2041 st->duration = AV_NOPTS_VALUE;
2042 st->start_time = component->start_position;
2043 if (material_track->edit_rate.num <= 0 ||
2044 material_track->edit_rate.den <= 0) {
2045 av_log(mxf->fc, AV_LOG_WARNING,
2046 "Invalid edit rate (%d/%d) found on stream #%d, "
2047 "defaulting to 25/1\n",
2048 material_track->edit_rate.num,
2049 material_track->edit_rate.den, st->index);
2050 material_track->edit_rate = (AVRational){25, 1};
2052 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
2054 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
2055 * the former is accessible via st->priv_data */
2056 source_track->edit_rate = material_track->edit_rate;
2058 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
2059 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
2060 st->codecpar->codec_type = codec_ul->id;
2063 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
2066 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
2067 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
2068 essence_container_ul = &descriptor->essence_container_ul;
2069 /* HACK: replacing the original key with mxf_encrypted_essence_container
2070 * is not allowed according to s429-6, try to find correct information anyway */
2071 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
2072 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
2073 for (k = 0; k < mxf->metadata_sets_count; k++) {
2074 MXFMetadataSet *metadata = mxf->metadata_sets[k];
2075 if (metadata->type == CryptoContext) {
2076 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
2082 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
2083 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
2084 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2085 if (st->codecpar->codec_id == AV_CODEC_ID_NONE) {
2086 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->codec_ul);
2087 st->codecpar->codec_id = (enum AVCodecID)codec_ul->id;
2090 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
2091 avcodec_get_name(st->codecpar->codec_id));
2092 for (k = 0; k < 16; k++) {
2093 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
2094 descriptor->essence_codec_ul[k]);
2095 if (!(k+1 & 19) || k == 5)
2096 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
2098 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
2100 mxf_add_umid_metadata(&st->metadata, "file_package_umid", source_package);
2101 if (source_package->name && source_package->name[0])
2102 av_dict_set(&st->metadata, "file_package_name", source_package->name, 0);
2103 if (material_track->name && material_track->name[0])
2104 av_dict_set(&st->metadata, "track_name", material_track->name, 0);
2106 mxf_parse_physical_source_package(mxf, source_track, st);
2108 if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
2109 source_track->intra_only = mxf_is_intra_only(descriptor);
2110 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
2111 if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
2112 st->codecpar->codec_id = container_ul->id;
2113 st->codecpar->width = descriptor->width;
2114 st->codecpar->height = descriptor->height; /* Field height, not frame height */
2115 switch (descriptor->frame_layout) {
2117 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2120 /* Every other line is stored and needs to be duplicated. */
2121 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
2122 break; /* The correct thing to do here is fall through, but by breaking we might be
2123 able to decode some streams at half the vertical resolution, rather than not al all.
2124 It's also for compatibility with the old behavior. */
2127 case SegmentedFrame:
2128 st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
2129 case SeparateFields:
2130 av_log(mxf->fc, AV_LOG_DEBUG, "video_line_map: (%d, %d), field_dominance: %d\n",
2131 descriptor->video_line_map[0], descriptor->video_line_map[1],
2132 descriptor->field_dominance);
2133 if ((descriptor->video_line_map[0] > 0) && (descriptor->video_line_map[1] > 0)) {
2134 /* Detect coded field order from VideoLineMap:
2135 * (even, even) => bottom field coded first
2136 * (even, odd) => top field coded first
2137 * (odd, even) => top field coded first
2138 * (odd, odd) => bottom field coded first
2140 if ((descriptor->video_line_map[0] + descriptor->video_line_map[1]) % 2) {
2141 switch (descriptor->field_dominance) {
2142 case MXF_FIELD_DOMINANCE_DEFAULT:
2143 case MXF_FIELD_DOMINANCE_FF:
2144 st->codecpar->field_order = AV_FIELD_TT;
2146 case MXF_FIELD_DOMINANCE_FL:
2147 st->codecpar->field_order = AV_FIELD_TB;
2150 avpriv_request_sample(mxf->fc,
2151 "Field dominance %d support",
2152 descriptor->field_dominance);
2155 switch (descriptor->field_dominance) {
2156 case MXF_FIELD_DOMINANCE_DEFAULT:
2157 case MXF_FIELD_DOMINANCE_FF:
2158 st->codecpar->field_order = AV_FIELD_BB;
2160 case MXF_FIELD_DOMINANCE_FL:
2161 st->codecpar->field_order = AV_FIELD_BT;
2164 avpriv_request_sample(mxf->fc,
2165 "Field dominance %d support",
2166 descriptor->field_dominance);
2170 /* Turn field height into frame height. */
2171 st->codecpar->height *= 2;
2174 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
2176 if (st->codecpar->codec_id == AV_CODEC_ID_RAWVIDEO) {
2177 st->codecpar->format = descriptor->pix_fmt;
2178 if (st->codecpar->format == AV_PIX_FMT_NONE) {
2179 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
2180 &descriptor->essence_codec_ul);
2181 st->codecpar->format = (enum AVPixelFormat)pix_fmt_ul->id;
2182 if (st->codecpar->format== AV_PIX_FMT_NONE) {
2183 st->codecpar->codec_tag = mxf_get_codec_ul(ff_mxf_codec_tag_uls,
2184 &descriptor->essence_codec_ul)->id;
2185 if (!st->codecpar->codec_tag) {
2186 /* support files created before RP224v10 by defaulting to UYVY422
2187 if subsampling is 4:2:2 and component depth is 8-bit */
2188 if (descriptor->horiz_subsampling == 2 &&
2189 descriptor->vert_subsampling == 1 &&
2190 descriptor->component_depth == 8) {
2191 st->codecpar->format = AV_PIX_FMT_UYVY422;
2197 st->need_parsing = AVSTREAM_PARSE_HEADERS;
2198 if (material_track->sequence->origin) {
2199 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
2201 if (source_track->sequence->origin) {
2202 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
2204 if (descriptor->aspect_ratio.num && descriptor->aspect_ratio.den)
2205 st->display_aspect_ratio = descriptor->aspect_ratio;
2206 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2207 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
2208 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
2209 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))
2210 st->codecpar->codec_id = (enum AVCodecID)container_ul->id;
2211 st->codecpar->channels = descriptor->channels;
2212 st->codecpar->bits_per_coded_sample = descriptor->bits_per_sample;
2214 if (descriptor->sample_rate.den > 0) {
2215 st->codecpar->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
2216 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
2218 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
2219 "found for stream #%d, time base forced to 1/48000\n",
2220 descriptor->sample_rate.num, descriptor->sample_rate.den,
2222 avpriv_set_pts_info(st, 64, 1, 48000);
2225 /* if duration is set, rescale it from EditRate to SampleRate */
2226 if (st->duration != AV_NOPTS_VALUE)
2227 st->duration = av_rescale_q(st->duration,
2228 av_inv_q(material_track->edit_rate),
2231 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
2232 if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16LE) {
2233 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2234 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24LE;
2235 else if (descriptor->bits_per_sample == 32)
2236 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32LE;
2237 } else if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S16BE) {
2238 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
2239 st->codecpar->codec_id = AV_CODEC_ID_PCM_S24BE;
2240 else if (descriptor->bits_per_sample == 32)
2241 st->codecpar->codec_id = AV_CODEC_ID_PCM_S32BE;
2242 } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
2243 st->need_parsing = AVSTREAM_PARSE_FULL;
2245 } else if (st->codecpar->codec_type == AVMEDIA_TYPE_DATA) {
2246 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
2247 essence_container_ul)->id;
2248 if (codec_id >= 0 &&
2249 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
2250 av_dict_set(&st->metadata, "data_type",
2251 mxf_data_essence_descriptor[codec_id], 0);
2254 if (descriptor->extradata) {
2255 if (!ff_alloc_extradata(st->codecpar, descriptor->extradata_size)) {
2256 memcpy(st->codecpar->extradata, descriptor->extradata, descriptor->extradata_size);
2258 } else if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
2259 int coded_width = mxf_get_codec_ul(mxf_intra_only_picture_coded_width,
2260 &descriptor->essence_codec_ul)->id;
2262 st->codecpar->width = coded_width;
2263 ret = ff_generate_avci_extradata(st);
2267 if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
2268 /* TODO: decode timestamps */
2269 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
2278 static int64_t mxf_timestamp_to_int64(uint64_t timestamp)
2280 struct tm time = { 0 };
2281 time.tm_year = (timestamp >> 48) - 1900;
2282 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
2283 time.tm_mday = (timestamp >> 32 & 0xFF);
2284 time.tm_hour = (timestamp >> 24 & 0xFF);
2285 time.tm_min = (timestamp >> 16 & 0xFF);
2286 time.tm_sec = (timestamp >> 8 & 0xFF);
2288 /* msvcrt versions of strftime calls the invalid parameter handler
2289 * (aborting the process if one isn't set) if the parameters are out
2291 time.tm_mon = av_clip(time.tm_mon, 0, 11);
2292 time.tm_mday = av_clip(time.tm_mday, 1, 31);
2293 time.tm_hour = av_clip(time.tm_hour, 0, 23);
2294 time.tm_min = av_clip(time.tm_min, 0, 59);
2295 time.tm_sec = av_clip(time.tm_sec, 0, 59);
2297 return (int64_t)av_timegm(&time) * 1000000;
2300 #define SET_STR_METADATA(pb, name, str) do { \
2301 if ((ret = mxf_read_utf16be_string(pb, size, &str)) < 0) \
2303 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2306 #define SET_UID_METADATA(pb, name, var, str) do { \
2307 avio_read(pb, var, 16); \
2308 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
2310 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
2313 #define SET_TS_METADATA(pb, name, var, str) do { \
2314 var = avio_rb64(pb); \
2315 if ((ret = avpriv_dict_set_timestamp(&s->metadata, name, mxf_timestamp_to_int64(var)) < 0)) \
2319 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
2321 MXFContext *mxf = arg;
2322 AVFormatContext *s = mxf->fc;
2329 SET_STR_METADATA(pb, "company_name", str);
2332 SET_STR_METADATA(pb, "product_name", str);
2335 SET_STR_METADATA(pb, "product_version", str);
2338 SET_UID_METADATA(pb, "product_uid", uid, str);
2341 SET_TS_METADATA(pb, "modification_date", ts, str);
2344 SET_STR_METADATA(pb, "application_platform", str);
2347 SET_UID_METADATA(pb, "generation_uid", uid, str);
2350 SET_UID_METADATA(pb, "uid", uid, str);
2356 static int mxf_read_preface_metadata(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
2358 MXFContext *mxf = arg;
2359 AVFormatContext *s = mxf->fc;
2363 if (tag >= 0x8000 && (IS_KLV_KEY(uid, mxf_avid_project_name))) {
2364 SET_STR_METADATA(pb, "project_name", str);
2369 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
2370 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
2371 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
2372 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
2373 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
2374 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
2375 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
2376 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
2377 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
2378 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
2379 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
2380 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
2381 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_metadata },
2382 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
2383 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
2384 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_package, sizeof(MXFPackage), SourcePackage },
2385 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_package, sizeof(MXFPackage), MaterialPackage },
2386 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
2387 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x05,0x00 }, mxf_read_essence_group, sizeof(MXFEssenceGroup), EssenceGroup},
2388 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
2389 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3f,0x00 }, mxf_read_tagged_value, sizeof(MXFTaggedValue), TaggedValue },
2390 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
2391 { { 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 */
2392 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
2393 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
2394 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
2395 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
2396 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
2397 { { 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 */
2398 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
2399 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
2400 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
2401 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
2402 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0c,0x00 }, mxf_read_pulldown_component, sizeof(MXFPulldownComponent), PulldownComponent },
2403 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
2404 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
2405 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
2408 static int mxf_metadataset_init(MXFMetadataSet *ctx, enum MXFMetadataSetType type)
2411 case MultipleDescriptor:
2413 ((MXFDescriptor*)ctx)->pix_fmt = AV_PIX_FMT_NONE;
2414 ((MXFDescriptor*)ctx)->duration = AV_NOPTS_VALUE;
2422 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
2424 AVIOContext *pb = mxf->fc->pb;
2425 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
2426 uint64_t klv_end = avio_tell(pb) + klv->length;
2429 return AVERROR(ENOMEM);
2430 mxf_metadataset_init(ctx, type);
2431 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
2433 int tag = avio_rb16(pb);
2434 int size = avio_rb16(pb); /* KLV specified by 0x53 */
2435 uint64_t next = avio_tell(pb) + size;
2438 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x size %d\n", tag, size);
2439 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
2440 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
2443 if (tag > 0x7FFF) { /* dynamic tag */
2445 for (i = 0; i < mxf->local_tags_count; i++) {
2446 int local_tag = AV_RB16(mxf->local_tags+i*18);
2447 if (local_tag == tag) {
2448 memcpy(uid, mxf->local_tags+i*18+2, 16);
2449 av_log(mxf->fc, AV_LOG_TRACE, "local tag %#04x\n", local_tag);
2450 PRINT_KEY(mxf->fc, "uid", uid);
2454 if (ctx_size && tag == 0x3C0A) {
2455 avio_read(pb, ctx->uid, 16);
2456 } else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
2457 mxf_free_metadataset(&ctx, !!ctx_size);
2461 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
2462 * it extending past the end of the KLV though (zzuf5.mxf). */
2463 if (avio_tell(pb) > klv_end) {
2466 mxf_free_metadataset(&ctx, !!ctx_size);
2469 av_log(mxf->fc, AV_LOG_ERROR,
2470 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
2472 return AVERROR_INVALIDDATA;
2473 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
2474 avio_seek(pb, next, SEEK_SET);
2476 if (ctx_size) ctx->type = type;
2477 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
2481 * Matches any partition pack key, in other words:
2485 * @return non-zero if the key is a partition pack key, zero otherwise
2487 static int mxf_is_partition_pack_key(UID key)
2489 //NOTE: this is a little lax since it doesn't constraint key[14]
2490 return !memcmp(key, mxf_header_partition_pack_key, 13) &&
2491 key[13] >= 2 && key[13] <= 4;
2495 * Parses a metadata KLV
2496 * @return <0 on error, 0 otherwise
2498 static int mxf_parse_klv(MXFContext *mxf, KLVPacket klv, MXFMetadataReadFunc *read,
2499 int ctx_size, enum MXFMetadataSetType type)
2501 AVFormatContext *s = mxf->fc;
2503 if (klv.key[5] == 0x53) {
2504 res = mxf_read_local_tags(mxf, &klv, read, ctx_size, type);
2506 uint64_t next = avio_tell(s->pb) + klv.length;
2507 res = read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2509 /* only seek forward, else this can loop for a long time */
2510 if (avio_tell(s->pb) > next) {
2511 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2513 return AVERROR_INVALIDDATA;
2516 avio_seek(s->pb, next, SEEK_SET);
2519 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2526 * Seeks to the previous partition and parses it, if possible
2527 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2529 static int mxf_seek_to_previous_partition(MXFContext *mxf)
2531 AVIOContext *pb = mxf->fc->pb;
2533 int64_t current_partition_ofs;
2536 if (!mxf->current_partition ||
2537 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
2538 return 0; /* we've parsed all partitions */
2540 /* seek to previous partition */
2541 current_partition_ofs = mxf->current_partition->pack_ofs; //includes run-in
2542 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
2543 mxf->current_partition = NULL;
2545 av_log(mxf->fc, AV_LOG_TRACE, "seeking to previous partition\n");
2547 /* Make sure this is actually a PartitionPack, and if so parse it.
2550 if ((ret = klv_read_packet(&klv, pb)) < 0) {
2551 av_log(mxf->fc, AV_LOG_ERROR, "failed to read PartitionPack KLV\n");
2555 if (!mxf_is_partition_pack_key(klv.key)) {
2556 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition @ %" PRIx64 " isn't a PartitionPack\n", klv.offset);
2557 return AVERROR_INVALIDDATA;
2560 /* We can't just check ofs >= current_partition_ofs because PreviousPartition
2561 * can point to just before the current partition, causing klv_read_packet()
2562 * to sync back up to it. See deadlock3.mxf
2564 if (klv.offset >= current_partition_ofs) {
2565 av_log(mxf->fc, AV_LOG_ERROR, "PreviousPartition for PartitionPack @ %"
2566 PRIx64 " indirectly points to itself\n", current_partition_ofs);
2567 return AVERROR_INVALIDDATA;
2570 if ((ret = mxf_parse_klv(mxf, klv, mxf_read_partition_pack, 0, 0)) < 0)
2577 * Called when essence is encountered
2578 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2580 static int mxf_parse_handle_essence(MXFContext *mxf)
2582 AVIOContext *pb = mxf->fc->pb;
2585 if (mxf->parsing_backward) {
2586 return mxf_seek_to_previous_partition(mxf);
2588 if (!mxf->footer_partition) {
2589 av_log(mxf->fc, AV_LOG_TRACE, "no FooterPartition\n");
2593 av_log(mxf->fc, AV_LOG_TRACE, "seeking to FooterPartition\n");
2595 /* remember where we were so we don't end up seeking further back than this */
2596 mxf->last_forward_tell = avio_tell(pb);
2598 if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
2599 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing FooterPartition\n");
2603 /* seek to FooterPartition and parse backward */
2604 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
2605 av_log(mxf->fc, AV_LOG_ERROR,
2606 "failed to seek to FooterPartition @ 0x%" PRIx64
2607 " (%"PRId64") - partial file?\n",
2608 mxf->run_in + mxf->footer_partition, ret);
2612 mxf->current_partition = NULL;
2613 mxf->parsing_backward = 1;
2620 * Called when the next partition or EOF is encountered
2621 * @return <= 0 if we should stop parsing, > 0 if we should keep going
2623 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
2625 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
2629 * Figures out the proper offset and length of the essence container in each partition
2631 static void mxf_compute_essence_containers(MXFContext *mxf)
2635 /* everything is already correct */
2636 if (mxf->op == OPAtom)
2639 for (x = 0; x < mxf->partitions_count; x++) {
2640 MXFPartition *p = &mxf->partitions[x];
2643 continue; /* BodySID == 0 -> no essence */
2645 if (x >= mxf->partitions_count - 1)
2646 break; /* FooterPartition - can't compute length (and we don't need to) */
2648 /* essence container spans to the next partition */
2649 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2651 if (p->essence_length < 0) {
2652 /* next ThisPartition < essence_offset */
2653 p->essence_length = 0;
2654 av_log(mxf->fc, AV_LOG_ERROR,
2655 "partition %i: bad ThisPartition = %"PRIX64"\n",
2656 x+1, mxf->partitions[x+1].this_partition);
2661 static int64_t round_to_kag(int64_t position, int kag_size)
2663 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2664 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2665 int64_t ret = (position / kag_size) * kag_size;
2666 return ret == position ? ret : ret + kag_size;
2669 static int is_pcm(enum AVCodecID codec_id)
2671 /* we only care about "normal" PCM codecs until we get samples */
2672 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2675 static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
2679 if (mxf->op != OPAtom)
2682 for (i = 0; i < mxf->fc->nb_streams; i++) {
2683 if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2685 return mxf->fc->streams[i];
2691 * Deal with the case where for some audio atoms EditUnitByteCount is
2692 * very small (2, 4..). In those cases we should read more than one
2693 * sample per call to mxf_read_packet().
2695 static void mxf_handle_small_eubc(AVFormatContext *s)
2697 MXFContext *mxf = s->priv_data;
2699 /* assuming non-OPAtom == frame wrapped
2700 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2701 AVStream *st = mxf_get_opatom_stream(mxf);
2705 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2706 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
2707 !is_pcm(st->codecpar->codec_id) ||
2708 mxf->nb_index_tables != 1 ||
2709 mxf->index_tables[0].nb_segments != 1 ||
2710 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2713 /* arbitrarily default to 48 kHz PAL audio frame size */
2714 /* TODO: We could compute this from the ratio between the audio
2715 * and video edit rates for 48 kHz NTSC we could use the
2716 * 1802-1802-1802-1802-1801 pattern. */
2717 mxf->edit_units_per_packet = 1920;
2721 * Deal with the case where OPAtom files does not have any IndexTableSegments.
2723 static int mxf_handle_missing_index_segment(MXFContext *mxf)
2725 AVFormatContext *s = mxf->fc;
2726 AVStream *st = NULL;
2727 MXFIndexTableSegment *segment = NULL;
2728 MXFPartition *p = NULL;
2729 int essence_partition_count = 0;
2732 st = mxf_get_opatom_stream(mxf);
2736 /* TODO: support raw video without an index if they exist */
2737 if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id))
2740 /* check if file already has a IndexTableSegment */
2741 for (i = 0; i < mxf->metadata_sets_count; i++) {
2742 if (mxf->metadata_sets[i]->type == IndexTableSegment)
2746 /* find the essence partition */
2747 for (i = 0; i < mxf->partitions_count; i++) {
2748 /* BodySID == 0 -> no essence */
2749 if (!mxf->partitions[i].body_sid)
2752 p = &mxf->partitions[i];
2753 essence_partition_count++;
2756 /* only handle files with a single essence partition */
2757 if (essence_partition_count != 1)
2760 if (!(segment = av_mallocz(sizeof(*segment))))
2761 return AVERROR(ENOMEM);
2763 if ((ret = mxf_add_metadata_set(mxf, segment))) {
2764 mxf_free_metadataset((MXFMetadataSet**)&segment, 1);
2768 segment->type = IndexTableSegment;
2769 /* stream will be treated as small EditUnitByteCount */
2770 segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
2771 segment->index_start_position = 0;
2772 segment->index_duration = s->streams[0]->duration;
2773 segment->index_sid = p->index_sid;
2774 segment->body_sid = p->body_sid;
2778 static void mxf_read_random_index_pack(AVFormatContext *s)
2780 MXFContext *mxf = s->priv_data;
2782 int64_t file_size, max_rip_length, min_rip_length;
2785 if (!(s->pb->seekable & AVIO_SEEKABLE_NORMAL))
2788 file_size = avio_size(s->pb);
2790 /* S377m says to check the RIP length for "silly" values, without defining "silly".
2791 * The limit below assumes a file with nothing but partition packs and a RIP.
2792 * Before changing this, consider that a muxer may place each sample in its own partition.
2794 * 105 is the size of the smallest possible PartitionPack
2795 * 12 is the size of each RIP entry
2796 * 28 is the size of the RIP header and footer, assuming an 8-byte BER
2798 max_rip_length = ((file_size - mxf->run_in) / 105) * 12 + 28;
2799 max_rip_length = FFMIN(max_rip_length, INT_MAX); //2 GiB and up is also silly
2801 /* We're only interested in RIPs with at least two entries.. */
2802 min_rip_length = 16+1+24+4;
2804 /* See S377m section 11 */
2805 avio_seek(s->pb, file_size - 4, SEEK_SET);
2806 length = avio_rb32(s->pb);
2808 if (length < min_rip_length || length > max_rip_length)
2810 avio_seek(s->pb, file_size - length, SEEK_SET);
2811 if (klv_read_packet(&klv, s->pb) < 0 ||
2812 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2813 klv.length != length - 20)
2816 avio_skip(s->pb, klv.length - 12);
2817 mxf->footer_partition = avio_rb64(s->pb);
2820 if (mxf->run_in + mxf->footer_partition >= file_size) {
2821 av_log(s, AV_LOG_WARNING, "bad FooterPartition in RIP - ignoring\n");
2822 mxf->footer_partition = 0;
2826 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2829 static int mxf_read_header(AVFormatContext *s)
2831 MXFContext *mxf = s->priv_data;
2833 int64_t essence_offset = 0;
2836 mxf->last_forward_tell = INT64_MAX;
2837 mxf->edit_units_per_packet = 1;
2839 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2840 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2841 return AVERROR_INVALIDDATA;
2843 avio_seek(s->pb, -14, SEEK_CUR);
2845 mxf->run_in = avio_tell(s->pb);
2847 mxf_read_random_index_pack(s);
2849 while (!avio_feof(s->pb)) {
2850 const MXFMetadataReadTableEntry *metadata;
2852 if (klv_read_packet(&klv, s->pb) < 0) {
2853 /* EOF - seek to previous partition or stop */
2854 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2860 PRINT_KEY(s, "read header", klv.key);
2861 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2862 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2863 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2864 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2865 IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
2866 IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
2868 if (!mxf->current_partition) {
2869 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2870 return AVERROR_INVALIDDATA;
2873 if (!mxf->current_partition->essence_offset) {
2874 /* for OP1a we compute essence_offset
2875 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2876 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2877 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2879 int64_t op1a_essence_offset =
2880 mxf->current_partition->this_partition +
2881 round_to_kag(mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2882 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2883 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2885 if (mxf->op == OPAtom) {
2886 /* point essence_offset to the actual data
2887 * OPAtom has all the essence in one big KLV
2889 mxf->current_partition->essence_offset = avio_tell(s->pb);
2890 mxf->current_partition->essence_length = klv.length;
2892 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2893 if (IS_KLV_KEY(klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(klv.key, mxf_system_item_key_gc))
2894 mxf->current_partition->essence_offset = klv.offset;
2896 mxf->current_partition->essence_offset = op1a_essence_offset;
2900 if (!essence_offset)
2901 essence_offset = klv.offset;
2903 /* seek to footer, previous partition or stop */
2904 if (mxf_parse_handle_essence(mxf) <= 0)
2907 } else if (mxf_is_partition_pack_key(klv.key) && mxf->current_partition) {
2908 /* next partition pack - keep going, seek to previous partition or stop */
2909 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2911 else if (mxf->parsing_backward)
2913 /* we're still parsing forward. proceed to parsing this partition pack */
2916 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2917 if (IS_KLV_KEY(klv.key, metadata->key)) {
2918 if ((ret = mxf_parse_klv(mxf, klv, metadata->read, metadata->ctx_size, metadata->type)) < 0)
2923 if (!metadata->read) {
2924 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2926 avio_skip(s->pb, klv.length);
2929 /* FIXME avoid seek */
2930 if (!essence_offset) {
2931 av_log(s, AV_LOG_ERROR, "no essence\n");
2932 ret = AVERROR_INVALIDDATA;
2935 avio_seek(s->pb, essence_offset, SEEK_SET);
2937 mxf_compute_essence_containers(mxf);
2939 /* we need to do this before computing the index tables
2940 * to be able to fill in zero IndexDurations with st->duration */
2941 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2944 mxf_handle_missing_index_segment(mxf);
2945 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2948 if (mxf->nb_index_tables > 1) {
2949 /* TODO: look up which IndexSID to use via EssenceContainerData */
2950 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2951 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2952 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2953 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2954 ret = AVERROR_INVALIDDATA;
2958 mxf_handle_small_eubc(s);
2968 * Sets mxf->current_edit_unit based on what offset we're currently at.
2969 * @return next_ofs if OK, <0 on error
2971 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2973 int64_t last_ofs = -1, next_ofs = -1;
2974 MXFIndexTable *t = &mxf->index_tables[0];
2976 /* this is called from the OP1a demuxing logic, which means there
2977 * may be no index tables */
2978 if (mxf->nb_index_tables <= 0)
2981 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2982 while (mxf->current_edit_unit >= 0) {
2983 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2986 if (next_ofs <= last_ofs) {
2987 /* large next_ofs didn't change or current_edit_unit wrapped
2988 * around this fixes the infinite loop on zzuf3.mxf */
2989 av_log(mxf->fc, AV_LOG_ERROR,
2990 "next_ofs didn't change. not deriving packet timestamps\n");
2994 if (next_ofs > current_offset)
2997 last_ofs = next_ofs;
2998 mxf->current_edit_unit++;
3001 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
3002 if (mxf->current_edit_unit < 0)
3008 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
3009 uint64_t *sample_count)
3011 int i, total = 0, size = 0;
3012 AVStream *st = mxf->fc->streams[stream_index];
3013 MXFTrack *track = st->priv_data;
3014 AVRational time_base = av_inv_q(track->edit_rate);
3015 AVRational sample_rate = av_inv_q(st->time_base);
3016 const MXFSamplesPerFrame *spf = NULL;
3018 if ((sample_rate.num / sample_rate.den) == 48000)
3019 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
3021 int remainder = (sample_rate.num * time_base.num) %
3022 (time_base.den * sample_rate.den);
3023 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
3024 av_mul_q(sample_rate, time_base)));
3026 av_log(mxf->fc, AV_LOG_WARNING,
3027 "seeking detected on stream #%d with time base (%d/%d) and "
3028 "sample rate (%d/%d), audio pts won't be accurate.\n",
3029 stream_index, time_base.num, time_base.den,
3030 sample_rate.num, sample_rate.den);
3034 while (spf->samples_per_frame[size]) {
3035 total += spf->samples_per_frame[size];
3041 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
3042 for (i = 0; i < mxf->current_edit_unit % size; i++) {
3043 *sample_count += spf->samples_per_frame[i];
3049 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
3052 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
3053 int64_t bits_per_sample = par->bits_per_coded_sample;
3055 if (!bits_per_sample)
3056 bits_per_sample = av_get_bits_per_sample(par->codec_id);
3058 pkt->pts = track->sample_count;
3060 if ( par->channels <= 0
3061 || bits_per_sample <= 0
3062 || par->channels * (int64_t)bits_per_sample < 8)
3063 return AVERROR(EINVAL);
3064 track->sample_count += pkt->size / (par->channels * (int64_t)bits_per_sample / 8);
3068 static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
3070 AVCodecParameters *par = st->codecpar;
3071 MXFTrack *track = st->priv_data;
3073 if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
3074 /* mxf->current_edit_unit good - see if we have an
3075 * index table to derive timestamps from */
3076 MXFIndexTable *t = &mxf->index_tables[0];
3078 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
3079 pkt->dts = mxf->current_edit_unit + t->first_dts;
3080 pkt->pts = t->ptses[mxf->current_edit_unit];
3081 } else if (track && track->intra_only) {
3082 /* intra-only -> PTS = EditUnit.
3083 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
3084 pkt->pts = mxf->current_edit_unit;
3086 } else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
3087 int ret = mxf_set_audio_pts(mxf, par, pkt);
3094 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
3097 MXFContext *mxf = s->priv_data;
3100 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
3101 PRINT_KEY(s, "read packet", klv.key);
3102 av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
3103 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
3104 ret = mxf_decrypt_triplet(s, pkt, &klv);
3106 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
3111 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
3112 IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
3113 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
3114 int index = mxf_get_stream_index(s, &klv);
3115 int64_t next_ofs, next_klv;
3119 av_log(s, AV_LOG_ERROR,
3120 "error getting stream index %"PRIu32"\n",
3121 AV_RB32(klv.key + 12));
3125 st = s->streams[index];
3127 if (s->streams[index]->discard == AVDISCARD_ALL)
3130 next_klv = avio_tell(s->pb) + klv.length;
3131 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
3133 if (next_ofs >= 0 && next_klv > next_ofs) {
3134 /* if this check is hit then it's possible OPAtom was treated as OP1a
3135 * truncate the packet since it's probably very large (>2 GiB is common) */
3136 avpriv_request_sample(s,
3137 "OPAtom misinterpreted as OP1a? "
3138 "KLV for edit unit %i extending into "
3140 mxf->current_edit_unit);
3141 klv.length = next_ofs - avio_tell(s->pb);
3144 /* check for 8 channels AES3 element */
3145 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
3146 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
3149 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
3153 ret = av_get_packet(s->pb, pkt, klv.length);
3157 pkt->stream_index = index;
3158 pkt->pos = klv.offset;
3160 ret = mxf_set_pts(mxf, st, pkt, next_ofs);
3164 /* seek for truncated packets */
3165 avio_seek(s->pb, next_klv, SEEK_SET);
3170 avio_skip(s->pb, klv.length);
3172 return avio_feof(s->pb) ? AVERROR_EOF : ret;
3175 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
3177 MXFContext *mxf = s->priv_data;
3179 int64_t ret64, pos, next_pos;
3184 if (mxf->op != OPAtom)
3185 return mxf_read_packet_old(s, pkt);
3187 // If we have no streams then we basically are at EOF
3188 st = mxf_get_opatom_stream(mxf);
3192 /* OPAtom - clip wrapped demuxing */
3193 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
3194 t = &mxf->index_tables[0];
3196 if (mxf->current_edit_unit >= st->duration)
3199 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
3201 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
3204 /* compute size by finding the next edit unit or the end of the essence container
3205 * not pretty, but it works */
3206 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
3207 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
3208 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
3209 return AVERROR_INVALIDDATA;
3212 if ((size = next_pos - pos) <= 0) {
3213 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
3214 return AVERROR_INVALIDDATA;
3217 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
3220 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
3223 pkt->stream_index = st->index;
3225 ret = mxf_set_pts(mxf, st, pkt, next_pos);
3229 mxf->current_edit_unit += edit_units;
3234 static int mxf_read_close(AVFormatContext *s)
3236 MXFContext *mxf = s->priv_data;
3239 av_freep(&mxf->packages_refs);
3241 for (i = 0; i < s->nb_streams; i++)
3242 s->streams[i]->priv_data = NULL;
3244 for (i = 0; i < mxf->metadata_sets_count; i++) {
3245 mxf_free_metadataset(mxf->metadata_sets + i, 1);
3247 av_freep(&mxf->partitions);
3248 av_freep(&mxf->metadata_sets);
3249 av_freep(&mxf->aesc);
3250 av_freep(&mxf->local_tags);
3252 if (mxf->index_tables) {
3253 for (i = 0; i < mxf->nb_index_tables; i++) {
3254 av_freep(&mxf->index_tables[i].segments);
3255 av_freep(&mxf->index_tables[i].ptses);
3256 av_freep(&mxf->index_tables[i].fake_index);
3257 av_freep(&mxf->index_tables[i].offsets);
3260 av_freep(&mxf->index_tables);
3265 static int mxf_probe(AVProbeData *p) {
3266 const uint8_t *bufp = p->buf;
3267 const uint8_t *end = p->buf + p->buf_size;
3269 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
3272 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
3273 end -= sizeof(mxf_header_partition_pack_key);
3275 for (; bufp < end;) {
3276 if (!((bufp[13] - 1) & 0xF2)){
3277 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
3278 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
3279 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
3280 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
3281 return AVPROBE_SCORE_MAX;
3290 /* rudimentary byte seek */
3291 /* XXX: use MXF Index */
3292 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
3294 AVStream *st = s->streams[stream_index];
3296 MXFContext* mxf = s->priv_data;
3300 MXFTrack *source_track = st->priv_data;
3302 if(st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
3305 /* if audio then truncate sample_time to EditRate */
3306 if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
3307 sample_time = av_rescale_q(sample_time, st->time_base,
3308 av_inv_q(source_track->edit_rate));
3310 if (mxf->nb_index_tables <= 0) {
3312 return AVERROR_INVALIDDATA;
3313 if (sample_time < 0)
3315 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
3317 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
3321 ff_update_cur_dts(s, st, sample_time);
3322 mxf->current_edit_unit = sample_time;
3324 t = &mxf->index_tables[0];
3326 /* clamp above zero, else ff_index_search_timestamp() returns negative
3327 * this also means we allow seeking before the start */
3328 sample_time = FFMAX(sample_time, 0);
3330 if (t->fake_index) {
3331 /* The first frames may not be keyframes in presentation order, so
3332 * we have to advance the target to be able to find the first
3333 * keyframe backwards... */
3334 if (!(flags & AVSEEK_FLAG_ANY) &&
3335 (flags & AVSEEK_FLAG_BACKWARD) &&
3336 t->ptses[0] != AV_NOPTS_VALUE &&
3337 sample_time < t->ptses[0] &&
3338 (t->fake_index[t->ptses[0]].flags & AVINDEX_KEYFRAME))
3339 sample_time = t->ptses[0];
3341 /* behave as if we have a proper index */
3342 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
3344 /* get the stored order index from the display order index */
3345 sample_time += t->offsets[sample_time];
3347 /* no IndexEntryArray (one or more CBR segments)
3348 * make sure we don't seek past the end */
3349 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
3352 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
3355 ff_update_cur_dts(s, st, sample_time);
3356 mxf->current_edit_unit = sample_time;
3357 avio_seek(s->pb, seekpos, SEEK_SET);
3360 // Update all tracks sample count
3361 for (i = 0; i < s->nb_streams; i++) {
3362 AVStream *cur_st = s->streams[i];
3363 MXFTrack *cur_track = cur_st->priv_data;
3364 uint64_t current_sample_count = 0;
3365 if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
3366 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
3370 cur_track->sample_count = current_sample_count;
3376 AVInputFormat ff_mxf_demuxer = {
3378 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
3379 .flags = AVFMT_SEEK_TO_PTS,
3380 .priv_data_size = sizeof(MXFContext),
3381 .read_probe = mxf_probe,
3382 .read_header = mxf_read_header,
3383 .read_packet = mxf_read_packet,
3384 .read_close = mxf_read_close,
3385 .read_seek = mxf_read_seek,