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/timecode.h"
75 OPSONYOpt, /* FATE sample, violates the spec in places */
81 MXFPartitionType type;
82 uint64_t previous_partition;
85 int64_t this_partition;
86 int64_t essence_offset; ///< absolute offset of essence
87 int64_t essence_length;
89 int64_t header_byte_count;
90 int64_t index_byte_count;
96 enum MXFMetadataSetType type;
97 UID source_container_ul;
102 enum MXFMetadataSetType type;
103 UID source_package_uid;
104 UID data_definition_ul;
106 int64_t start_position;
108 } MXFStructuralComponent;
112 enum MXFMetadataSetType type;
113 UID data_definition_ul;
114 UID *structural_components_refs;
115 int structural_components_count;
122 enum MXFMetadataSetType type;
125 struct AVRational rate;
127 } MXFTimecodeComponent;
131 enum MXFMetadataSetType type;
132 MXFSequence *sequence; /* mandatory, and only one */
135 uint8_t track_number[4];
136 AVRational edit_rate;
138 uint64_t sample_count;
139 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
144 enum MXFMetadataSetType type;
145 UID essence_container_ul;
146 UID essence_codec_ul;
147 AVRational sample_rate;
148 AVRational aspect_ratio;
150 int height; /* Field height, not frame height */
151 int frame_layout; /* See MXFFrameLayout enum */
157 unsigned int component_depth;
158 unsigned int horiz_subsampling;
159 unsigned int vert_subsampling;
160 UID *sub_descriptors_refs;
161 int sub_descriptors_count;
165 enum AVPixelFormat pix_fmt;
170 enum MXFMetadataSetType type;
171 int edit_unit_byte_count;
174 AVRational index_edit_rate;
175 uint64_t index_start_position;
176 uint64_t index_duration;
177 int8_t *temporal_offset_entries;
179 uint64_t *stream_offset_entries;
180 int nb_index_entries;
181 } MXFIndexTableSegment;
185 enum MXFMetadataSetType type;
189 MXFDescriptor *descriptor; /* only one */
195 enum MXFMetadataSetType type;
198 /* decoded index table */
202 int nb_ptses; /* number of PTSes or total duration of index */
203 int64_t first_dts; /* DTS = EditUnit + first_dts */
204 int64_t *ptses; /* maps EditUnit -> PTS */
206 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
207 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
211 MXFPartition *partitions;
212 unsigned partitions_count;
216 MXFMetadataSet **metadata_sets;
217 int metadata_sets_count;
221 int local_tags_count;
222 uint64_t last_partition;
223 uint64_t footer_partition;
224 KLVPacket current_klv_data;
225 int current_klv_index;
227 MXFPartition *current_partition;
228 int parsing_backward;
229 int64_t last_forward_tell;
230 int last_forward_partition;
231 int current_edit_unit;
233 MXFIndexTable *index_tables;
234 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
237 enum MXFWrappingScheme {
242 /* NOTE: klv_offset is not set (-1) for local keys */
243 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
247 MXFMetadataReadFunc *read;
249 enum MXFMetadataSetType type;
250 } MXFMetadataReadTableEntry;
252 static int mxf_read_close(AVFormatContext *s);
254 /* partial keys to match */
255 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
256 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
257 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
258 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
259 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
260 /* complete keys to match */
261 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 };
262 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
263 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
264 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 };
265 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
267 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
269 static int64_t klv_decode_ber_length(AVIOContext *pb)
271 uint64_t size = avio_r8(pb);
272 if (size & 0x80) { /* long form */
273 int bytes_num = size & 0x7f;
274 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
276 return AVERROR_INVALIDDATA;
279 size = size << 8 | avio_r8(pb);
284 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
287 for (i = 0; i < size && !avio_feof(pb); i++) {
291 else if (b != key[i])
297 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
299 if (!mxf_read_sync(pb, mxf_klv_key, 4))
300 return AVERROR_INVALIDDATA;
301 klv->offset = avio_tell(pb) - 4;
302 memcpy(klv->key, mxf_klv_key, 4);
303 avio_read(pb, klv->key + 4, 12);
304 klv->length = klv_decode_ber_length(pb);
305 return klv->length == -1 ? -1 : 0;
308 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
312 for (i = 0; i < s->nb_streams; i++) {
313 MXFTrack *track = s->streams[i]->priv_data;
315 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
318 /* return 0 if only one stream, for OP Atom files with 0 as track number */
319 return s->nb_streams == 1 ? 0 : -1;
322 /* XXX: use AVBitStreamFilter */
323 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
325 const uint8_t *buf_ptr, *end_ptr;
329 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
330 return AVERROR_INVALIDDATA;
331 length = av_get_packet(pb, pkt, length);
334 data_ptr = pkt->data;
335 end_ptr = pkt->data + length;
336 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
337 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
338 for (i = 0; i < st->codec->channels; i++) {
339 uint32_t sample = bytestream_get_le32(&buf_ptr);
340 if (st->codec->bits_per_coded_sample == 24)
341 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
343 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
345 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
347 av_shrink_packet(pkt, data_ptr - pkt->data);
351 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
353 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
354 MXFContext *mxf = s->priv_data;
355 AVIOContext *pb = s->pb;
356 int64_t end = avio_tell(pb) + klv->length;
359 uint64_t plaintext_size;
364 if (!mxf->aesc && s->key && s->keylen == 16) {
365 mxf->aesc = av_aes_alloc();
367 return AVERROR(ENOMEM);
368 av_aes_init(mxf->aesc, s->key, 128, 1);
371 avio_skip(pb, klv_decode_ber_length(pb));
373 klv_decode_ber_length(pb);
374 plaintext_size = avio_rb64(pb);
376 klv_decode_ber_length(pb);
377 avio_read(pb, klv->key, 16);
378 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
379 return AVERROR_INVALIDDATA;
380 index = mxf_get_stream_index(s, klv);
382 return AVERROR_INVALIDDATA;
384 klv_decode_ber_length(pb);
385 orig_size = avio_rb64(pb);
386 if (orig_size < plaintext_size)
387 return AVERROR_INVALIDDATA;
389 size = klv_decode_ber_length(pb);
390 if (size < 32 || size - 32 < orig_size)
391 return AVERROR_INVALIDDATA;
392 avio_read(pb, ivec, 16);
393 avio_read(pb, tmpbuf, 16);
395 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
396 if (memcmp(tmpbuf, checkv, 16))
397 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
399 size = av_get_packet(pb, pkt, size);
402 else if (size < plaintext_size)
403 return AVERROR_INVALIDDATA;
404 size -= plaintext_size;
406 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
407 &pkt->data[plaintext_size], size >> 4, ivec, 1);
408 av_shrink_packet(pkt, orig_size);
409 pkt->stream_index = index;
410 avio_skip(pb, end - avio_tell(pb));
414 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
416 MXFContext *mxf = arg;
417 int item_num = avio_rb32(pb);
418 int item_len = avio_rb32(pb);
420 if (item_len != 18) {
421 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
422 return AVERROR_PATCHWELCOME;
424 if (item_num > 65536) {
425 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
426 return AVERROR_INVALIDDATA;
428 mxf->local_tags = av_calloc(item_num, item_len);
429 if (!mxf->local_tags)
430 return AVERROR(ENOMEM);
431 mxf->local_tags_count = item_num;
432 avio_read(pb, mxf->local_tags, item_num*item_len);
436 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
438 MXFContext *mxf = arg;
439 MXFPartition *partition, *tmp_part;
441 uint64_t footer_partition;
442 uint32_t nb_essence_containers;
444 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
446 return AVERROR(ENOMEM);
447 mxf->partitions = tmp_part;
449 if (mxf->parsing_backward) {
450 /* insert the new partition pack in the middle
451 * this makes the entries in mxf->partitions sorted by offset */
452 memmove(&mxf->partitions[mxf->last_forward_partition+1],
453 &mxf->partitions[mxf->last_forward_partition],
454 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
455 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
457 mxf->last_forward_partition++;
458 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
461 memset(partition, 0, sizeof(*partition));
462 mxf->partitions_count++;
463 partition->pack_length = avio_tell(pb) - klv_offset + size;
467 partition->type = Header;
470 partition->type = BodyPartition;
473 partition->type = Footer;
476 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
477 return AVERROR_INVALIDDATA;
480 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
481 partition->closed = partition->type == Footer || !(uid[14] & 1);
482 partition->complete = uid[14] > 2;
484 partition->kag_size = avio_rb32(pb);
485 partition->this_partition = avio_rb64(pb);
486 partition->previous_partition = avio_rb64(pb);
487 footer_partition = avio_rb64(pb);
488 partition->header_byte_count = avio_rb64(pb);
489 partition->index_byte_count = avio_rb64(pb);
490 partition->index_sid = avio_rb32(pb);
492 partition->body_sid = avio_rb32(pb);
493 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
494 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
495 return AVERROR_INVALIDDATA;
497 nb_essence_containers = avio_rb32(pb);
499 if (partition->this_partition &&
500 partition->previous_partition == partition->this_partition) {
501 av_log(mxf->fc, AV_LOG_ERROR,
502 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
503 partition->previous_partition);
504 /* override with the actual previous partition offset */
505 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
507 mxf->partitions + mxf->last_forward_partition - 2;
508 partition->previous_partition = prev->this_partition;
510 /* if no previous body partition are found point to the header
512 if (partition->previous_partition == partition->this_partition)
513 partition->previous_partition = 0;
514 av_log(mxf->fc, AV_LOG_ERROR,
515 "Overriding PreviousPartition with %"PRIx64"\n",
516 partition->previous_partition);
519 /* some files don'thave FooterPartition set in every partition */
520 if (footer_partition) {
521 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
522 av_log(mxf->fc, AV_LOG_ERROR,
523 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
524 mxf->footer_partition, footer_partition);
526 mxf->footer_partition = footer_partition;
531 "PartitionPack: ThisPartition = 0x%"PRIX64
532 ", PreviousPartition = 0x%"PRIX64", "
533 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
534 partition->this_partition,
535 partition->previous_partition, footer_partition,
536 partition->index_sid, partition->body_sid);
538 /* sanity check PreviousPartition if set */
539 if (partition->previous_partition &&
540 mxf->run_in + partition->previous_partition >= klv_offset) {
541 av_log(mxf->fc, AV_LOG_ERROR,
542 "PreviousPartition points to this partition or forward\n");
543 return AVERROR_INVALIDDATA;
546 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
547 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
548 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
549 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
550 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
551 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
552 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
553 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
554 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
555 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
556 else if (op[12] == 0x10) {
557 /* SMPTE 390m: "There shall be exactly one essence container"
558 * The following block deals with files that violate this, namely:
559 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
560 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
561 if (nb_essence_containers != 1) {
562 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
566 av_log(mxf->fc, AV_LOG_WARNING,
567 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
568 nb_essence_containers,
569 op == OP1a ? "OP1a" : "OPAtom");
575 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
579 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
580 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
581 partition->kag_size);
583 if (mxf->op == OPSONYOpt)
584 partition->kag_size = 512;
586 partition->kag_size = 1;
588 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
594 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
596 MXFMetadataSet **tmp;
598 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
600 return AVERROR(ENOMEM);
601 mxf->metadata_sets = tmp;
602 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
603 mxf->metadata_sets_count++;
607 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
609 MXFCryptoContext *cryptocontext = arg;
611 return AVERROR_INVALIDDATA;
612 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
613 avio_read(pb, cryptocontext->source_container_ul, 16);
617 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
619 MXFContext *mxf = arg;
622 mxf->packages_count = avio_rb32(pb);
623 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
624 if (!mxf->packages_refs)
625 return AVERROR(ENOMEM);
626 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
627 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
633 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
635 MXFStructuralComponent *source_clip = arg;
638 source_clip->duration = avio_rb64(pb);
641 source_clip->start_position = avio_rb64(pb);
644 /* UMID, only get last 16 bytes */
646 avio_read(pb, source_clip->source_package_uid, 16);
649 source_clip->source_track_id = avio_rb32(pb);
655 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
657 MXFPackage *package = arg;
660 package->tracks_count = avio_rb32(pb);
661 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
662 if (!package->tracks_refs)
663 return AVERROR(ENOMEM);
664 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
665 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
671 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
673 MXFTimecodeComponent *mxf_timecode = arg;
676 mxf_timecode->start_frame = avio_rb64(pb);
679 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
682 mxf_timecode->drop_frame = avio_r8(pb);
688 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
690 MXFTrack *track = arg;
693 track->track_id = avio_rb32(pb);
696 avio_read(pb, track->track_number, 4);
699 track->edit_rate.num = avio_rb32(pb);
700 track->edit_rate.den = avio_rb32(pb);
703 avio_read(pb, track->sequence_ref, 16);
709 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
711 MXFSequence *sequence = arg;
714 sequence->duration = avio_rb64(pb);
717 avio_read(pb, sequence->data_definition_ul, 16);
720 sequence->origin = avio_r8(pb);
723 sequence->structural_components_count = avio_rb32(pb);
724 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
725 if (!sequence->structural_components_refs)
726 return AVERROR(ENOMEM);
727 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
728 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
734 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
736 MXFPackage *package = arg;
739 package->tracks_count = avio_rb32(pb);
740 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
741 if (!package->tracks_refs)
742 return AVERROR(ENOMEM);
743 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
744 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
747 /* UMID, only get last 16 bytes */
749 avio_read(pb, package->package_uid, 16);
752 avio_read(pb, package->descriptor_ref, 16);
758 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
762 segment->nb_index_entries = avio_rb32(pb);
764 length = avio_rb32(pb);
766 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
767 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
768 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
769 return AVERROR(ENOMEM);
771 for (i = 0; i < segment->nb_index_entries; i++) {
772 segment->temporal_offset_entries[i] = avio_r8(pb);
773 avio_r8(pb); /* KeyFrameOffset */
774 segment->flag_entries[i] = avio_r8(pb);
775 segment->stream_offset_entries[i] = avio_rb64(pb);
776 avio_skip(pb, length - 11);
781 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
783 MXFIndexTableSegment *segment = arg;
786 segment->edit_unit_byte_count = avio_rb32(pb);
787 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
790 segment->index_sid = avio_rb32(pb);
791 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
794 segment->body_sid = avio_rb32(pb);
795 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
798 av_dlog(NULL, "IndexEntryArray found\n");
799 return mxf_read_index_entry_array(pb, segment);
801 segment->index_edit_rate.num = avio_rb32(pb);
802 segment->index_edit_rate.den = avio_rb32(pb);
803 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
804 segment->index_edit_rate.den);
807 segment->index_start_position = avio_rb64(pb);
808 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
811 segment->index_duration = avio_rb64(pb);
812 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
818 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
820 int code, value, ofs = 0;
821 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
826 av_dlog(NULL, "pixel layout: code %#x\n", code);
829 layout[ofs++] = code;
830 layout[ofs++] = value;
832 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
833 } while (code != 0); /* SMPTE 377M E.2.46 */
835 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
838 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
840 MXFDescriptor *descriptor = arg;
841 descriptor->pix_fmt = AV_PIX_FMT_NONE;
844 descriptor->sub_descriptors_count = avio_rb32(pb);
845 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
846 if (!descriptor->sub_descriptors_refs)
847 return AVERROR(ENOMEM);
848 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
849 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
852 avio_read(pb, descriptor->essence_container_ul, 16);
855 descriptor->linked_track_id = avio_rb32(pb);
857 case 0x3201: /* PictureEssenceCoding */
858 avio_read(pb, descriptor->essence_codec_ul, 16);
861 descriptor->width = avio_rb32(pb);
864 descriptor->height = avio_rb32(pb);
867 descriptor->frame_layout = avio_r8(pb);
870 descriptor->aspect_ratio.num = avio_rb32(pb);
871 descriptor->aspect_ratio.den = avio_rb32(pb);
874 descriptor->field_dominance = avio_r8(pb);
877 descriptor->component_depth = avio_rb32(pb);
880 descriptor->horiz_subsampling = avio_rb32(pb);
883 descriptor->vert_subsampling = avio_rb32(pb);
886 descriptor->sample_rate.num = avio_rb32(pb);
887 descriptor->sample_rate.den = avio_rb32(pb);
889 case 0x3D06: /* SoundEssenceCompression */
890 avio_read(pb, descriptor->essence_codec_ul, 16);
893 descriptor->channels = avio_rb32(pb);
896 descriptor->bits_per_sample = avio_rb32(pb);
899 mxf_read_pixel_layout(pb, descriptor);
902 /* Private uid used by SONY C0023S01.mxf */
903 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
904 if (descriptor->extradata)
905 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
906 av_free(descriptor->extradata);
907 descriptor->extradata_size = 0;
908 descriptor->extradata = av_malloc(size);
909 if (!descriptor->extradata)
910 return AVERROR(ENOMEM);
911 descriptor->extradata_size = size;
912 avio_read(pb, descriptor->extradata, size);
920 * Match an uid independently of the version byte and up to len common bytes
923 static int mxf_match_uid(const UID key, const UID uid, int len)
926 for (i = 0; i < len; i++) {
927 if (i != 7 && key[i] != uid[i])
933 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
935 while (uls->uid[0]) {
936 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
943 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
949 for (i = 0; i < mxf->metadata_sets_count; i++) {
950 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
951 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
952 return mxf->metadata_sets[i];
958 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
959 // video essence container uls
960 { { 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 */
961 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
962 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
963 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
966 /* EC ULs for intra-only formats */
967 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
968 { { 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 */
969 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
972 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
973 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
974 { { 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 */
975 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
976 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
979 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
980 // sound essence container uls
981 { { 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 */
982 { { 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 */
983 { { 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 */
984 { { 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 */
985 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG2 AAC ADTS (legacy) */
986 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
989 static const MXFCodecUL mxf_data_essence_container_uls[] = {
990 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
991 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE },
994 static const char* const mxf_data_essence_descriptor[] = {
995 "vbi_vanc_smpte_436M",
998 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
1000 int i, j, nb_segments = 0;
1001 MXFIndexTableSegment **unsorted_segments;
1002 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1004 /* count number of segments, allocate arrays and copy unsorted segments */
1005 for (i = 0; i < mxf->metadata_sets_count; i++)
1006 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1010 return AVERROR_INVALIDDATA;
1012 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1013 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1014 av_freep(sorted_segments);
1015 av_free(unsorted_segments);
1016 return AVERROR(ENOMEM);
1019 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1020 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1021 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1023 *nb_sorted_segments = 0;
1025 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1026 for (i = 0; i < nb_segments; i++) {
1027 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1028 uint64_t best_index_duration = 0;
1030 for (j = 0; j < nb_segments; j++) {
1031 MXFIndexTableSegment *s = unsorted_segments[j];
1033 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1034 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1035 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1037 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1038 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1039 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1041 best_body_sid = s->body_sid;
1042 best_index_sid = s->index_sid;
1043 best_index_start = s->index_start_position;
1044 best_index_duration = s->index_duration;
1048 /* no suitable entry found -> we're done */
1052 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1053 last_body_sid = best_body_sid;
1054 last_index_sid = best_index_sid;
1055 last_index_start = best_index_start;
1058 av_free(unsorted_segments);
1064 * Computes the absolute file offset of the given essence container offset
1066 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1069 int64_t offset_in = offset; /* for logging */
1071 for (x = 0; x < mxf->partitions_count; x++) {
1072 MXFPartition *p = &mxf->partitions[x];
1074 if (p->body_sid != body_sid)
1077 if (offset < p->essence_length || !p->essence_length) {
1078 *offset_out = p->essence_offset + offset;
1082 offset -= p->essence_length;
1085 av_log(mxf->fc, AV_LOG_ERROR,
1086 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1087 offset_in, body_sid);
1089 return AVERROR_INVALIDDATA;
1093 * Returns the end position of the essence container with given BodySID, or zero if unknown
1095 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1100 for (x = 0; x < mxf->partitions_count; x++) {
1101 MXFPartition *p = &mxf->partitions[x];
1103 if (p->body_sid != body_sid)
1106 if (!p->essence_length)
1109 ret = p->essence_offset + p->essence_length;
1115 /* EditUnit -> absolute offset */
1116 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)
1119 int64_t offset_temp = 0;
1121 for (i = 0; i < index_table->nb_segments; i++) {
1122 MXFIndexTableSegment *s = index_table->segments[i];
1124 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1126 if (edit_unit < s->index_start_position + s->index_duration) {
1127 int64_t index = edit_unit - s->index_start_position;
1129 if (s->edit_unit_byte_count)
1130 offset_temp += s->edit_unit_byte_count * index;
1131 else if (s->nb_index_entries) {
1132 if (s->nb_index_entries == 2 * s->index_duration + 1)
1133 index *= 2; /* Avid index */
1135 if (index < 0 || index >= s->nb_index_entries) {
1136 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1137 index_table->index_sid, s->index_start_position);
1138 return AVERROR_INVALIDDATA;
1141 offset_temp = s->stream_offset_entries[index];
1143 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1144 index_table->index_sid, s->index_start_position);
1145 return AVERROR_INVALIDDATA;
1149 *edit_unit_out = edit_unit;
1151 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1153 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1154 offset_temp += s->edit_unit_byte_count * s->index_duration;
1159 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);
1161 return AVERROR_INVALIDDATA;
1164 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1167 int8_t max_temporal_offset = -128;
1169 /* first compute how many entries we have */
1170 for (i = 0; i < index_table->nb_segments; i++) {
1171 MXFIndexTableSegment *s = index_table->segments[i];
1173 if (!s->nb_index_entries) {
1174 index_table->nb_ptses = 0;
1175 return 0; /* no TemporalOffsets */
1178 index_table->nb_ptses += s->index_duration;
1181 /* paranoid check */
1182 if (index_table->nb_ptses <= 0)
1185 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1186 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1187 av_freep(&index_table->ptses);
1188 return AVERROR(ENOMEM);
1191 /* we may have a few bad TemporalOffsets
1192 * make sure the corresponding PTSes don't have the bogus value 0 */
1193 for (x = 0; x < index_table->nb_ptses; x++)
1194 index_table->ptses[x] = AV_NOPTS_VALUE;
1208 * We want to transform it into this:
1219 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1220 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1221 * The latter makes DTS <= PTS.
1223 for (i = x = 0; i < index_table->nb_segments; i++) {
1224 MXFIndexTableSegment *s = index_table->segments[i];
1225 int index_delta = 1;
1226 int n = s->nb_index_entries;
1228 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1229 index_delta = 2; /* Avid index */
1230 /* ignore the last entry - it's the size of the essence container */
1234 for (j = 0; j < n; j += index_delta, x++) {
1235 int offset = s->temporal_offset_entries[j] / index_delta;
1236 int index = x + offset;
1238 if (x >= index_table->nb_ptses) {
1239 av_log(mxf->fc, AV_LOG_ERROR,
1240 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1241 s->nb_index_entries, s->index_duration);
1245 index_table->fake_index[x].timestamp = x;
1246 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1248 if (index < 0 || index >= index_table->nb_ptses) {
1249 av_log(mxf->fc, AV_LOG_ERROR,
1250 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1255 index_table->ptses[index] = x;
1256 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1260 index_table->first_dts = -max_temporal_offset;
1266 * Sorts and collects index table segments into index tables.
1267 * Also computes PTSes if possible.
1269 static int mxf_compute_index_tables(MXFContext *mxf)
1271 int i, j, k, ret, nb_sorted_segments;
1272 MXFIndexTableSegment **sorted_segments = NULL;
1274 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1275 nb_sorted_segments <= 0) {
1276 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1280 /* sanity check and count unique BodySIDs/IndexSIDs */
1281 for (i = 0; i < nb_sorted_segments; i++) {
1282 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1283 mxf->nb_index_tables++;
1284 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1285 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1286 ret = AVERROR_INVALIDDATA;
1287 goto finish_decoding_index;
1291 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1292 sizeof(*mxf->index_tables));
1293 if (!mxf->index_tables) {
1294 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1295 ret = AVERROR(ENOMEM);
1296 goto finish_decoding_index;
1299 /* distribute sorted segments to index tables */
1300 for (i = j = 0; i < nb_sorted_segments; i++) {
1301 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1306 mxf->index_tables[j].nb_segments++;
1309 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1310 MXFIndexTable *t = &mxf->index_tables[j];
1312 t->segments = av_mallocz_array(t->nb_segments,
1313 sizeof(*t->segments));
1316 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1317 " pointer array\n");
1318 ret = AVERROR(ENOMEM);
1319 goto finish_decoding_index;
1322 if (sorted_segments[i]->index_start_position)
1323 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1324 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1326 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1327 t->index_sid = sorted_segments[i]->index_sid;
1328 t->body_sid = sorted_segments[i]->body_sid;
1330 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1331 goto finish_decoding_index;
1333 /* fix zero IndexDurations */
1334 for (k = 0; k < t->nb_segments; k++) {
1335 if (t->segments[k]->index_duration)
1338 if (t->nb_segments > 1)
1339 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1342 if (mxf->fc->nb_streams <= 0) {
1343 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1347 /* assume the first stream's duration is reasonable
1348 * leave index_duration = 0 on further segments in case we have any (unlikely)
1350 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1356 finish_decoding_index:
1357 av_free(sorted_segments);
1361 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1363 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1364 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1365 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1366 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1369 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1371 char buf[AV_TIMECODE_STR_SIZE];
1372 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1377 static int mxf_parse_structural_metadata(MXFContext *mxf)
1379 MXFPackage *material_package = NULL;
1380 MXFPackage *temp_package = NULL;
1383 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1384 /* TODO: handle multiple material packages (OP3x) */
1385 for (i = 0; i < mxf->packages_count; i++) {
1386 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1387 if (material_package) break;
1389 if (!material_package) {
1390 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1391 return AVERROR_INVALIDDATA;
1394 for (i = 0; i < material_package->tracks_count; i++) {
1395 MXFPackage *source_package = NULL;
1396 MXFTrack *material_track = NULL;
1397 MXFTrack *source_track = NULL;
1398 MXFTrack *temp_track = NULL;
1399 MXFDescriptor *descriptor = NULL;
1400 MXFStructuralComponent *component = NULL;
1401 MXFTimecodeComponent *mxf_tc = NULL;
1402 UID *essence_container_ul = NULL;
1403 const MXFCodecUL *codec_ul = NULL;
1404 const MXFCodecUL *container_ul = NULL;
1405 const MXFCodecUL *pix_fmt_ul = NULL;
1410 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1411 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1415 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1416 mxf_tc = (MXFTimecodeComponent*)component;
1417 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1418 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1419 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1423 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1424 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1428 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1429 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1433 mxf_tc = (MXFTimecodeComponent*)component;
1434 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1435 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1436 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1441 /* TODO: handle multiple source clips */
1442 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1443 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1447 for (k = 0; k < mxf->packages_count; k++) {
1448 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1451 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1452 source_package = temp_package;
1456 if (!source_package) {
1457 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1460 for (k = 0; k < source_package->tracks_count; k++) {
1461 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1462 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1463 ret = AVERROR_INVALIDDATA;
1466 if (temp_track->track_id == component->source_track_id) {
1467 source_track = temp_track;
1471 if (!source_track) {
1472 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1476 if (!source_track || !component)
1479 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1480 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1481 ret = AVERROR_INVALIDDATA;
1485 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1486 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1487 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1488 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1492 st = avformat_new_stream(mxf->fc, NULL);
1494 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1495 ret = AVERROR(ENOMEM);
1498 st->id = source_track->track_id;
1499 st->priv_data = source_track;
1500 source_track->original_duration = st->duration = component->duration;
1501 if (st->duration == -1)
1502 st->duration = AV_NOPTS_VALUE;
1503 st->start_time = component->start_position;
1504 if (material_track->edit_rate.num <= 0 ||
1505 material_track->edit_rate.den <= 0) {
1506 av_log(mxf->fc, AV_LOG_WARNING,
1507 "Invalid edit rate (%d/%d) found on stream #%d, "
1508 "defaulting to 25/1\n",
1509 material_track->edit_rate.num,
1510 material_track->edit_rate.den, st->index);
1511 material_track->edit_rate = (AVRational){25, 1};
1513 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1515 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1516 * the former is accessible via st->priv_data */
1517 source_track->edit_rate = material_track->edit_rate;
1519 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1520 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1521 st->codec->codec_type = codec_ul->id;
1523 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1524 if (source_package->descriptor) {
1525 if (source_package->descriptor->type == MultipleDescriptor) {
1526 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1527 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1529 if (!sub_descriptor) {
1530 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1533 if (sub_descriptor->linked_track_id == source_track->track_id) {
1534 descriptor = sub_descriptor;
1538 } else if (source_package->descriptor->type == Descriptor)
1539 descriptor = source_package->descriptor;
1542 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1545 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1546 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1547 essence_container_ul = &descriptor->essence_container_ul;
1548 /* HACK: replacing the original key with mxf_encrypted_essence_container
1549 * is not allowed according to s429-6, try to find correct information anyway */
1550 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1551 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1552 for (k = 0; k < mxf->metadata_sets_count; k++) {
1553 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1554 if (metadata->type == CryptoContext) {
1555 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1561 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1562 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1563 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1564 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1565 avcodec_get_name(st->codec->codec_id));
1566 for (k = 0; k < 16; k++) {
1567 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1568 descriptor->essence_codec_ul[k]);
1569 if (!(k+1 & 19) || k == 5)
1570 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1572 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1574 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1575 source_track->intra_only = mxf_is_intra_only(descriptor);
1576 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1577 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1578 st->codec->codec_id = container_ul->id;
1579 st->codec->width = descriptor->width;
1580 st->codec->height = descriptor->height; /* Field height, not frame height */
1581 switch (descriptor->frame_layout) {
1582 case SegmentedFrame:
1583 /* This one is a weird layout I don't fully understand. */
1584 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1587 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1590 /* Every other line is stored and needs to be duplicated. */
1591 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1592 break; /* The correct thing to do here is fall through, but by breaking we might be
1593 able to decode some streams at half the vertical resolution, rather than not al all.
1594 It's also for compatibility with the old behavior. */
1597 case SeparateFields:
1598 switch (descriptor->field_dominance) {
1600 st->codec->field_order = AV_FIELD_TT;
1603 st->codec->field_order = AV_FIELD_BB;
1606 avpriv_request_sample(mxf->fc,
1607 "Field dominance %d support",
1608 descriptor->field_dominance);
1611 /* Turn field height into frame height. */
1612 st->codec->height *= 2;
1615 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1617 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1618 st->codec->pix_fmt = descriptor->pix_fmt;
1619 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1620 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1621 &descriptor->essence_codec_ul);
1622 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1623 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1624 /* support files created before RP224v10 by defaulting to UYVY422
1625 if subsampling is 4:2:2 and component depth is 8-bit */
1626 if (descriptor->horiz_subsampling == 2 &&
1627 descriptor->vert_subsampling == 1 &&
1628 descriptor->component_depth == 8) {
1629 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1634 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1635 if (material_track->sequence->origin) {
1636 av_dict_set_int(&st->metadata, "material_track_origin", material_track->sequence->origin, 0);
1638 if (source_track->sequence->origin) {
1639 av_dict_set_int(&st->metadata, "source_track_origin", source_track->sequence->origin, 0);
1641 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1642 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1643 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1644 if (st->codec->codec_id == AV_CODEC_ID_NONE || (st->codec->codec_id == AV_CODEC_ID_PCM_ALAW && (enum AVCodecID)container_ul->id != AV_CODEC_ID_NONE))
1645 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1646 st->codec->channels = descriptor->channels;
1647 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1649 if (descriptor->sample_rate.den > 0) {
1650 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1651 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1653 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1654 "found for stream #%d, time base forced to 1/48000\n",
1655 descriptor->sample_rate.num, descriptor->sample_rate.den,
1657 avpriv_set_pts_info(st, 64, 1, 48000);
1660 /* if duration is set, rescale it from EditRate to SampleRate */
1661 if (st->duration != AV_NOPTS_VALUE)
1662 st->duration = av_rescale_q(st->duration,
1663 av_inv_q(material_track->edit_rate),
1666 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1667 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1668 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1669 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1670 else if (descriptor->bits_per_sample == 32)
1671 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1672 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1673 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1674 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1675 else if (descriptor->bits_per_sample == 32)
1676 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1677 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1678 st->need_parsing = AVSTREAM_PARSE_FULL;
1680 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1681 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1682 essence_container_ul)->id;
1683 if (codec_id >= 0 &&
1684 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1685 av_dict_set(&st->metadata, "data_type",
1686 mxf_data_essence_descriptor[codec_id], 0);
1689 if (descriptor->extradata) {
1690 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1691 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1693 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1694 ret = ff_generate_avci_extradata(st);
1698 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1699 /* TODO: decode timestamps */
1700 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1709 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1715 return AVERROR(EINVAL);
1717 buf_size = size + size / 2 + 1;
1718 *str = av_malloc(buf_size);
1720 return AVERROR(ENOMEM);
1722 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1730 static int mxf_uid_to_str(UID uid, char **str)
1734 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1736 return AVERROR(ENOMEM);
1737 for (i = 0; i < sizeof(UID); i++) {
1738 snprintf(p, 2 + 1, "%.2x", uid[i]);
1740 if (i == 3 || i == 5 || i == 7 || i == 9) {
1741 snprintf(p, 1 + 1, "-");
1748 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1750 struct tm time = { 0 };
1751 time.tm_year = (timestamp >> 48) - 1900;
1752 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1753 time.tm_mday = (timestamp >> 32 & 0xFF);
1754 time.tm_hour = (timestamp >> 24 & 0xFF);
1755 time.tm_min = (timestamp >> 16 & 0xFF);
1756 time.tm_sec = (timestamp >> 8 & 0xFF);
1758 /* msvcrt versions of strftime calls the invalid parameter handler
1759 * (aborting the process if one isn't set) if the parameters are out
1761 time.tm_mon = av_clip(time.tm_mon, 0, 11);
1762 time.tm_mday = av_clip(time.tm_mday, 1, 31);
1763 time.tm_hour = av_clip(time.tm_hour, 0, 23);
1764 time.tm_min = av_clip(time.tm_min, 0, 59);
1765 time.tm_sec = av_clip(time.tm_sec, 0, 59);
1767 *str = av_mallocz(32);
1769 return AVERROR(ENOMEM);
1770 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1775 #define SET_STR_METADATA(pb, name, str) do { \
1776 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1778 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1781 #define SET_UID_METADATA(pb, name, var, str) do { \
1782 avio_read(pb, var, 16); \
1783 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1785 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1788 #define SET_TS_METADATA(pb, name, var, str) do { \
1789 var = avio_rb64(pb); \
1790 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1792 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1795 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1797 MXFContext *mxf = arg;
1798 AVFormatContext *s = mxf->fc;
1805 SET_STR_METADATA(pb, "company_name", str);
1808 SET_STR_METADATA(pb, "product_name", str);
1811 SET_STR_METADATA(pb, "product_version", str);
1814 SET_UID_METADATA(pb, "product_uid", uid, str);
1817 SET_TS_METADATA(pb, "modification_date", ts, str);
1820 SET_STR_METADATA(pb, "application_platform", str);
1823 SET_UID_METADATA(pb, "generation_uid", uid, str);
1826 SET_UID_METADATA(pb, "uid", uid, str);
1832 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1833 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1834 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1835 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1836 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1837 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1838 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1839 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1840 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1841 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1842 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1843 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1844 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1845 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1846 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1847 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1848 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1849 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1850 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1851 { { 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 */
1852 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1853 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1854 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG 2 Video */
1855 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1856 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1857 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */
1858 { { 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 */
1859 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */
1860 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1861 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1862 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1863 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1864 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1865 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1868 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1870 AVIOContext *pb = mxf->fc->pb;
1871 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1872 uint64_t klv_end = avio_tell(pb) + klv->length;
1875 return AVERROR(ENOMEM);
1876 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
1878 int tag = avio_rb16(pb);
1879 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1880 uint64_t next = avio_tell(pb) + size;
1883 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1884 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1885 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1888 if (tag > 0x7FFF) { /* dynamic tag */
1890 for (i = 0; i < mxf->local_tags_count; i++) {
1891 int local_tag = AV_RB16(mxf->local_tags+i*18);
1892 if (local_tag == tag) {
1893 memcpy(uid, mxf->local_tags+i*18+2, 16);
1894 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1895 PRINT_KEY(mxf->fc, "uid", uid);
1899 if (ctx_size && tag == 0x3C0A)
1900 avio_read(pb, ctx->uid, 16);
1901 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1904 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1905 * it extending past the end of the KLV though (zzuf5.mxf). */
1906 if (avio_tell(pb) > klv_end) {
1910 av_log(mxf->fc, AV_LOG_ERROR,
1911 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1913 return AVERROR_INVALIDDATA;
1914 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1915 avio_seek(pb, next, SEEK_SET);
1917 if (ctx_size) ctx->type = type;
1918 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1922 * Seeks to the previous partition, if possible
1923 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1925 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1927 AVIOContext *pb = mxf->fc->pb;
1929 if (!mxf->current_partition ||
1930 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1931 return 0; /* we've parsed all partitions */
1933 /* seek to previous partition */
1934 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1935 mxf->current_partition = NULL;
1937 av_dlog(mxf->fc, "seeking to previous partition\n");
1943 * Called when essence is encountered
1944 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1946 static int mxf_parse_handle_essence(MXFContext *mxf)
1948 AVIOContext *pb = mxf->fc->pb;
1951 if (mxf->parsing_backward) {
1952 return mxf_seek_to_previous_partition(mxf);
1954 uint64_t offset = mxf->footer_partition ? mxf->footer_partition
1955 : mxf->last_partition;
1958 av_dlog(mxf->fc, "no last partition\n");
1962 av_dlog(mxf->fc, "seeking to last partition\n");
1964 /* remember where we were so we don't end up seeking further back than this */
1965 mxf->last_forward_tell = avio_tell(pb);
1967 if (!pb->seekable) {
1968 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1972 /* seek to last partition and parse backward */
1973 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1974 av_log(mxf->fc, AV_LOG_ERROR,
1975 "failed to seek to last partition @ 0x%" PRIx64
1976 " (%"PRId64") - partial file?\n",
1977 mxf->run_in + offset, ret);
1981 mxf->current_partition = NULL;
1982 mxf->parsing_backward = 1;
1989 * Called when the next partition or EOF is encountered
1990 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1992 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1994 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1998 * Figures out the proper offset and length of the essence container in each partition
2000 static void mxf_compute_essence_containers(MXFContext *mxf)
2004 /* everything is already correct */
2005 if (mxf->op == OPAtom)
2008 for (x = 0; x < mxf->partitions_count; x++) {
2009 MXFPartition *p = &mxf->partitions[x];
2012 continue; /* BodySID == 0 -> no essence */
2014 if (x >= mxf->partitions_count - 1)
2015 break; /* last partition - can't compute length (and we don't need to) */
2017 /* essence container spans to the next partition */
2018 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2020 if (p->essence_length < 0) {
2021 /* next ThisPartition < essence_offset */
2022 p->essence_length = 0;
2023 av_log(mxf->fc, AV_LOG_ERROR,
2024 "partition %i: bad ThisPartition = %"PRIX64"\n",
2025 x+1, mxf->partitions[x+1].this_partition);
2030 static int64_t round_to_kag(int64_t position, int kag_size)
2032 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2033 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2034 int64_t ret = (position / kag_size) * kag_size;
2035 return ret == position ? ret : ret + kag_size;
2038 static int is_pcm(enum AVCodecID codec_id)
2040 /* we only care about "normal" PCM codecs until we get samples */
2041 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2045 * Deal with the case where for some audio atoms EditUnitByteCount is
2046 * very small (2, 4..). In those cases we should read more than one
2047 * sample per call to mxf_read_packet().
2049 static void mxf_handle_small_eubc(AVFormatContext *s)
2051 MXFContext *mxf = s->priv_data;
2053 /* assuming non-OPAtom == frame wrapped
2054 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2055 if (mxf->op != OPAtom)
2058 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2059 if (s->nb_streams != 1 ||
2060 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2061 !is_pcm(s->streams[0]->codec->codec_id) ||
2062 mxf->nb_index_tables != 1 ||
2063 mxf->index_tables[0].nb_segments != 1 ||
2064 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2067 /* arbitrarily default to 48 kHz PAL audio frame size */
2068 /* TODO: We could compute this from the ratio between the audio
2069 * and video edit rates for 48 kHz NTSC we could use the
2070 * 1802-1802-1802-1802-1801 pattern. */
2071 mxf->edit_units_per_packet = 1920;
2074 static void mxf_read_random_index_pack(AVFormatContext *s)
2076 MXFContext *mxf = s->priv_data;
2081 if (!s->pb->seekable)
2084 file_size = avio_size(s->pb);
2085 avio_seek(s->pb, file_size - 4, SEEK_SET);
2086 length = avio_rb32(s->pb);
2087 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2089 avio_seek(s->pb, file_size - length, SEEK_SET);
2090 if (klv_read_packet(&klv, s->pb) < 0 ||
2091 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2092 klv.length != length - 20)
2095 avio_skip(s->pb, klv.length - 12);
2096 mxf->last_partition = avio_rb64(s->pb);
2099 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2102 static int mxf_read_header(AVFormatContext *s)
2104 MXFContext *mxf = s->priv_data;
2106 int64_t essence_offset = 0;
2107 int64_t last_pos = -1;
2108 uint64_t last_pos_index = 1;
2111 mxf->last_forward_tell = INT64_MAX;
2112 mxf->edit_units_per_packet = 1;
2114 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2115 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2116 return AVERROR_INVALIDDATA;
2118 avio_seek(s->pb, -14, SEEK_CUR);
2120 mxf->run_in = avio_tell(s->pb);
2122 mxf_read_random_index_pack(s);
2124 while (!avio_feof(s->pb)) {
2125 const MXFMetadataReadTableEntry *metadata;
2126 if (avio_tell(s->pb) == last_pos) {
2127 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2128 return AVERROR_INVALIDDATA;
2130 if ((1ULL<<61) % last_pos_index++ == 0)
2131 last_pos = avio_tell(s->pb);
2132 if (klv_read_packet(&klv, s->pb) < 0) {
2133 /* EOF - seek to previous partition or stop */
2134 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2140 PRINT_KEY(s, "read header", klv.key);
2141 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2142 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2143 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2144 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2145 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2147 if (!mxf->current_partition) {
2148 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2149 return AVERROR_INVALIDDATA;
2152 if (!mxf->current_partition->essence_offset) {
2153 /* for OP1a we compute essence_offset
2154 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2155 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2156 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2158 int64_t op1a_essence_offset =
2159 round_to_kag(mxf->current_partition->this_partition +
2160 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2161 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2162 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2164 if (mxf->op == OPAtom) {
2165 /* point essence_offset to the actual data
2166 * OPAtom has all the essence in one big KLV
2168 mxf->current_partition->essence_offset = avio_tell(s->pb);
2169 mxf->current_partition->essence_length = klv.length;
2171 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2172 mxf->current_partition->essence_offset = op1a_essence_offset;
2176 if (!essence_offset)
2177 essence_offset = klv.offset;
2179 /* seek to footer, previous partition or stop */
2180 if (mxf_parse_handle_essence(mxf) <= 0)
2183 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2184 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2185 /* next partition pack - keep going, seek to previous partition or stop */
2186 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2188 else if (mxf->parsing_backward)
2190 /* we're still parsing forward. proceed to parsing this partition pack */
2193 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2194 if (IS_KLV_KEY(klv.key, metadata->key)) {
2196 if (klv.key[5] == 0x53) {
2197 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2199 uint64_t next = avio_tell(s->pb) + klv.length;
2200 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2202 /* only seek forward, else this can loop for a long time */
2203 if (avio_tell(s->pb) > next) {
2204 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2206 return AVERROR_INVALIDDATA;
2209 avio_seek(s->pb, next, SEEK_SET);
2212 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2217 av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n",
2221 if (!metadata->read)
2222 avio_skip(s->pb, klv.length);
2224 /* FIXME avoid seek */
2225 if (!essence_offset) {
2226 av_log(s, AV_LOG_ERROR, "no essence\n");
2227 return AVERROR_INVALIDDATA;
2229 avio_seek(s->pb, essence_offset, SEEK_SET);
2231 mxf_compute_essence_containers(mxf);
2233 /* we need to do this before computing the index tables
2234 * to be able to fill in zero IndexDurations with st->duration */
2235 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2238 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2241 if (mxf->nb_index_tables > 1) {
2242 /* TODO: look up which IndexSID to use via EssenceContainerData */
2243 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2244 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2245 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2246 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2247 ret = AVERROR_INVALIDDATA;
2251 mxf_handle_small_eubc(s);
2261 * Sets mxf->current_edit_unit based on what offset we're currently at.
2262 * @return next_ofs if OK, <0 on error
2264 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2266 int64_t last_ofs = -1, next_ofs = -1;
2267 MXFIndexTable *t = &mxf->index_tables[0];
2269 /* this is called from the OP1a demuxing logic, which means there
2270 * may be no index tables */
2271 if (mxf->nb_index_tables <= 0)
2274 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2275 while (mxf->current_edit_unit >= 0) {
2276 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2279 if (next_ofs <= last_ofs) {
2280 /* large next_ofs didn't change or current_edit_unit wrapped
2281 * around this fixes the infinite loop on zzuf3.mxf */
2282 av_log(mxf->fc, AV_LOG_ERROR,
2283 "next_ofs didn't change. not deriving packet timestamps\n");
2287 if (next_ofs > current_offset)
2290 last_ofs = next_ofs;
2291 mxf->current_edit_unit++;
2294 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2295 if (mxf->current_edit_unit < 0)
2301 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2302 uint64_t *sample_count)
2304 int i, total = 0, size = 0;
2305 AVStream *st = mxf->fc->streams[stream_index];
2306 MXFTrack *track = st->priv_data;
2307 AVRational time_base = av_inv_q(track->edit_rate);
2308 AVRational sample_rate = av_inv_q(st->time_base);
2309 const MXFSamplesPerFrame *spf = NULL;
2311 if ((sample_rate.num / sample_rate.den) == 48000)
2312 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2314 int remainder = (sample_rate.num * time_base.num) %
2315 (time_base.den * sample_rate.den);
2316 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2317 av_mul_q(sample_rate, time_base)));
2319 av_log(mxf->fc, AV_LOG_WARNING,
2320 "seeking detected on stream #%d with time base (%d/%d) and "
2321 "sample rate (%d/%d), audio pts won't be accurate.\n",
2322 stream_index, time_base.num, time_base.den,
2323 sample_rate.num, sample_rate.den);
2327 while (spf->samples_per_frame[size]) {
2328 total += spf->samples_per_frame[size];
2334 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2335 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2336 *sample_count += spf->samples_per_frame[i];
2342 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2345 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2346 int64_t bits_per_sample = codec->bits_per_coded_sample;
2348 if (!bits_per_sample)
2349 bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2351 pkt->pts = track->sample_count;
2353 if ( codec->channels <= 0
2354 || bits_per_sample <= 0
2355 || codec->channels * (int64_t)bits_per_sample < 8)
2356 return AVERROR(EINVAL);
2357 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2361 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2364 MXFContext *mxf = s->priv_data;
2367 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2368 PRINT_KEY(s, "read packet", klv.key);
2369 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2370 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2371 ret = mxf_decrypt_triplet(s, pkt, &klv);
2373 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2378 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2379 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2380 int index = mxf_get_stream_index(s, &klv);
2381 int64_t next_ofs, next_klv;
2384 AVCodecContext *codec;
2387 av_log(s, AV_LOG_ERROR,
2388 "error getting stream index %"PRIu32"\n",
2389 AV_RB32(klv.key + 12));
2393 st = s->streams[index];
2394 track = st->priv_data;
2396 if (s->streams[index]->discard == AVDISCARD_ALL)
2399 next_klv = avio_tell(s->pb) + klv.length;
2400 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2402 if (next_ofs >= 0 && next_klv > next_ofs) {
2403 /* if this check is hit then it's possible OPAtom was treated as OP1a
2404 * truncate the packet since it's probably very large (>2 GiB is common) */
2405 avpriv_request_sample(s,
2406 "OPAtom misinterpreted as OP1a?"
2407 "KLV for edit unit %i extending into "
2409 mxf->current_edit_unit);
2410 klv.length = next_ofs - avio_tell(s->pb);
2413 /* check for 8 channels AES3 element */
2414 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2415 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2418 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2422 ret = av_get_packet(s->pb, pkt, klv.length);
2426 pkt->stream_index = index;
2427 pkt->pos = klv.offset;
2429 codec = s->streams[index]->codec;
2431 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2432 /* mxf->current_edit_unit good - see if we have an
2433 * index table to derive timestamps from */
2434 MXFIndexTable *t = &mxf->index_tables[0];
2436 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2437 pkt->dts = mxf->current_edit_unit + t->first_dts;
2438 pkt->pts = t->ptses[mxf->current_edit_unit];
2439 } else if (track->intra_only) {
2440 /* intra-only -> PTS = EditUnit.
2441 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2442 pkt->pts = mxf->current_edit_unit;
2444 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2445 ret = mxf_set_audio_pts(mxf, codec, pkt);
2450 /* seek for truncated packets */
2451 avio_seek(s->pb, next_klv, SEEK_SET);
2456 avio_skip(s->pb, klv.length);
2458 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2461 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2463 MXFContext *mxf = s->priv_data;
2465 int64_t ret64, pos, next_pos;
2470 if (mxf->op != OPAtom)
2471 return mxf_read_packet_old(s, pkt);
2473 /* OPAtom - clip wrapped demuxing */
2474 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2476 t = &mxf->index_tables[0];
2478 if (mxf->current_edit_unit >= st->duration)
2481 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2483 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2486 /* compute size by finding the next edit unit or the end of the essence container
2487 * not pretty, but it works */
2488 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2489 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2490 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2491 return AVERROR_INVALIDDATA;
2494 if ((size = next_pos - pos) <= 0) {
2495 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2496 return AVERROR_INVALIDDATA;
2499 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2502 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2505 pkt->stream_index = 0;
2507 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2508 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2509 pkt->dts = mxf->current_edit_unit + t->first_dts;
2510 pkt->pts = t->ptses[mxf->current_edit_unit];
2511 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2512 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2517 mxf->current_edit_unit += edit_units;
2522 static int mxf_read_close(AVFormatContext *s)
2524 MXFContext *mxf = s->priv_data;
2525 MXFIndexTableSegment *seg;
2528 av_freep(&mxf->packages_refs);
2530 for (i = 0; i < s->nb_streams; i++)
2531 s->streams[i]->priv_data = NULL;
2533 for (i = 0; i < mxf->metadata_sets_count; i++) {
2534 switch (mxf->metadata_sets[i]->type) {
2536 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2538 case MultipleDescriptor:
2539 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2542 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2545 case MaterialPackage:
2546 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2548 case IndexTableSegment:
2549 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2550 av_freep(&seg->temporal_offset_entries);
2551 av_freep(&seg->flag_entries);
2552 av_freep(&seg->stream_offset_entries);
2557 av_freep(&mxf->metadata_sets[i]);
2559 av_freep(&mxf->partitions);
2560 av_freep(&mxf->metadata_sets);
2561 av_freep(&mxf->aesc);
2562 av_freep(&mxf->local_tags);
2564 if (mxf->index_tables) {
2565 for (i = 0; i < mxf->nb_index_tables; i++) {
2566 av_freep(&mxf->index_tables[i].segments);
2567 av_freep(&mxf->index_tables[i].ptses);
2568 av_freep(&mxf->index_tables[i].fake_index);
2571 av_freep(&mxf->index_tables);
2576 static int mxf_probe(AVProbeData *p) {
2577 const uint8_t *bufp = p->buf;
2578 const uint8_t *end = p->buf + p->buf_size;
2580 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2583 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2584 end -= sizeof(mxf_header_partition_pack_key);
2586 for (; bufp < end;) {
2587 if (!((bufp[13] - 1) & 0xF2)){
2588 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2589 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2590 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2591 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2592 return AVPROBE_SCORE_MAX;
2601 /* rudimentary byte seek */
2602 /* XXX: use MXF Index */
2603 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2605 AVStream *st = s->streams[stream_index];
2607 MXFContext* mxf = s->priv_data;
2611 MXFTrack *source_track = st->priv_data;
2613 /* if audio then truncate sample_time to EditRate */
2614 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2615 sample_time = av_rescale_q(sample_time, st->time_base,
2616 av_inv_q(source_track->edit_rate));
2618 if (mxf->nb_index_tables <= 0) {
2620 return AVERROR_INVALIDDATA;
2621 if (sample_time < 0)
2623 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2625 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2629 ff_update_cur_dts(s, st, sample_time);
2630 mxf->current_edit_unit = sample_time;
2632 t = &mxf->index_tables[0];
2634 /* clamp above zero, else ff_index_search_timestamp() returns negative
2635 * this also means we allow seeking before the start */
2636 sample_time = FFMAX(sample_time, 0);
2638 if (t->fake_index) {
2639 /* behave as if we have a proper index */
2640 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2643 /* no IndexEntryArray (one or more CBR segments)
2644 * make sure we don't seek past the end */
2645 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2648 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2651 ff_update_cur_dts(s, st, sample_time);
2652 mxf->current_edit_unit = sample_time;
2653 avio_seek(s->pb, seekpos, SEEK_SET);
2656 // Update all tracks sample count
2657 for (i = 0; i < s->nb_streams; i++) {
2658 AVStream *cur_st = s->streams[i];
2659 MXFTrack *cur_track = cur_st->priv_data;
2660 uint64_t current_sample_count = 0;
2661 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2662 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2666 cur_track->sample_count = current_sample_count;
2672 AVInputFormat ff_mxf_demuxer = {
2674 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2675 .priv_data_size = sizeof(MXFContext),
2676 .read_probe = mxf_probe,
2677 .read_header = mxf_read_header,
2678 .read_packet = mxf_read_packet,
2679 .read_close = mxf_read_close,
2680 .read_seek = mxf_read_seek,