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 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
988 static const MXFCodecUL mxf_data_essence_container_uls[] = {
989 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 },
990 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE },
993 static const char* const mxf_data_essence_descriptor[] = {
994 "vbi_vanc_smpte_436M",
997 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
999 int i, j, nb_segments = 0;
1000 MXFIndexTableSegment **unsorted_segments;
1001 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
1003 /* count number of segments, allocate arrays and copy unsorted segments */
1004 for (i = 0; i < mxf->metadata_sets_count; i++)
1005 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1009 return AVERROR_INVALIDDATA;
1011 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
1012 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1013 av_freep(sorted_segments);
1014 av_free(unsorted_segments);
1015 return AVERROR(ENOMEM);
1018 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1019 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1020 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1022 *nb_sorted_segments = 0;
1024 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1025 for (i = 0; i < nb_segments; i++) {
1026 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1027 uint64_t best_index_duration = 0;
1029 for (j = 0; j < nb_segments; j++) {
1030 MXFIndexTableSegment *s = unsorted_segments[j];
1032 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1033 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1034 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1036 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1037 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1038 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1040 best_body_sid = s->body_sid;
1041 best_index_sid = s->index_sid;
1042 best_index_start = s->index_start_position;
1043 best_index_duration = s->index_duration;
1047 /* no suitable entry found -> we're done */
1051 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1052 last_body_sid = best_body_sid;
1053 last_index_sid = best_index_sid;
1054 last_index_start = best_index_start;
1057 av_free(unsorted_segments);
1063 * Computes the absolute file offset of the given essence container offset
1065 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1068 int64_t offset_in = offset; /* for logging */
1070 for (x = 0; x < mxf->partitions_count; x++) {
1071 MXFPartition *p = &mxf->partitions[x];
1073 if (p->body_sid != body_sid)
1076 if (offset < p->essence_length || !p->essence_length) {
1077 *offset_out = p->essence_offset + offset;
1081 offset -= p->essence_length;
1084 av_log(mxf->fc, AV_LOG_ERROR,
1085 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1086 offset_in, body_sid);
1088 return AVERROR_INVALIDDATA;
1092 * Returns the end position of the essence container with given BodySID, or zero if unknown
1094 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1099 for (x = 0; x < mxf->partitions_count; x++) {
1100 MXFPartition *p = &mxf->partitions[x];
1102 if (p->body_sid != body_sid)
1105 if (!p->essence_length)
1108 ret = p->essence_offset + p->essence_length;
1114 /* EditUnit -> absolute offset */
1115 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)
1118 int64_t offset_temp = 0;
1120 for (i = 0; i < index_table->nb_segments; i++) {
1121 MXFIndexTableSegment *s = index_table->segments[i];
1123 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1125 if (edit_unit < s->index_start_position + s->index_duration) {
1126 int64_t index = edit_unit - s->index_start_position;
1128 if (s->edit_unit_byte_count)
1129 offset_temp += s->edit_unit_byte_count * index;
1130 else if (s->nb_index_entries) {
1131 if (s->nb_index_entries == 2 * s->index_duration + 1)
1132 index *= 2; /* Avid index */
1134 if (index < 0 || index >= s->nb_index_entries) {
1135 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1136 index_table->index_sid, s->index_start_position);
1137 return AVERROR_INVALIDDATA;
1140 offset_temp = s->stream_offset_entries[index];
1142 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1143 index_table->index_sid, s->index_start_position);
1144 return AVERROR_INVALIDDATA;
1148 *edit_unit_out = edit_unit;
1150 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1152 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1153 offset_temp += s->edit_unit_byte_count * s->index_duration;
1158 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);
1160 return AVERROR_INVALIDDATA;
1163 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1166 int8_t max_temporal_offset = -128;
1168 /* first compute how many entries we have */
1169 for (i = 0; i < index_table->nb_segments; i++) {
1170 MXFIndexTableSegment *s = index_table->segments[i];
1172 if (!s->nb_index_entries) {
1173 index_table->nb_ptses = 0;
1174 return 0; /* no TemporalOffsets */
1177 index_table->nb_ptses += s->index_duration;
1180 /* paranoid check */
1181 if (index_table->nb_ptses <= 0)
1184 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1185 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1186 av_freep(&index_table->ptses);
1187 return AVERROR(ENOMEM);
1190 /* we may have a few bad TemporalOffsets
1191 * make sure the corresponding PTSes don't have the bogus value 0 */
1192 for (x = 0; x < index_table->nb_ptses; x++)
1193 index_table->ptses[x] = AV_NOPTS_VALUE;
1207 * We want to transform it into this:
1218 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1219 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1220 * The latter makes DTS <= PTS.
1222 for (i = x = 0; i < index_table->nb_segments; i++) {
1223 MXFIndexTableSegment *s = index_table->segments[i];
1224 int index_delta = 1;
1225 int n = s->nb_index_entries;
1227 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1228 index_delta = 2; /* Avid index */
1229 /* ignore the last entry - it's the size of the essence container */
1233 for (j = 0; j < n; j += index_delta, x++) {
1234 int offset = s->temporal_offset_entries[j] / index_delta;
1235 int index = x + offset;
1237 if (x >= index_table->nb_ptses) {
1238 av_log(mxf->fc, AV_LOG_ERROR,
1239 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1240 s->nb_index_entries, s->index_duration);
1244 index_table->fake_index[x].timestamp = x;
1245 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1247 if (index < 0 || index >= index_table->nb_ptses) {
1248 av_log(mxf->fc, AV_LOG_ERROR,
1249 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1254 index_table->ptses[index] = x;
1255 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1259 index_table->first_dts = -max_temporal_offset;
1265 * Sorts and collects index table segments into index tables.
1266 * Also computes PTSes if possible.
1268 static int mxf_compute_index_tables(MXFContext *mxf)
1270 int i, j, k, ret, nb_sorted_segments;
1271 MXFIndexTableSegment **sorted_segments = NULL;
1273 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1274 nb_sorted_segments <= 0) {
1275 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1279 /* sanity check and count unique BodySIDs/IndexSIDs */
1280 for (i = 0; i < nb_sorted_segments; i++) {
1281 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1282 mxf->nb_index_tables++;
1283 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1284 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1285 ret = AVERROR_INVALIDDATA;
1286 goto finish_decoding_index;
1290 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1291 sizeof(*mxf->index_tables));
1292 if (!mxf->index_tables) {
1293 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1294 ret = AVERROR(ENOMEM);
1295 goto finish_decoding_index;
1298 /* distribute sorted segments to index tables */
1299 for (i = j = 0; i < nb_sorted_segments; i++) {
1300 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1305 mxf->index_tables[j].nb_segments++;
1308 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1309 MXFIndexTable *t = &mxf->index_tables[j];
1311 t->segments = av_mallocz_array(t->nb_segments,
1312 sizeof(*t->segments));
1315 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1316 " pointer array\n");
1317 ret = AVERROR(ENOMEM);
1318 goto finish_decoding_index;
1321 if (sorted_segments[i]->index_start_position)
1322 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1323 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1325 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1326 t->index_sid = sorted_segments[i]->index_sid;
1327 t->body_sid = sorted_segments[i]->body_sid;
1329 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1330 goto finish_decoding_index;
1332 /* fix zero IndexDurations */
1333 for (k = 0; k < t->nb_segments; k++) {
1334 if (t->segments[k]->index_duration)
1337 if (t->nb_segments > 1)
1338 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1341 if (mxf->fc->nb_streams <= 0) {
1342 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1346 /* assume the first stream's duration is reasonable
1347 * leave index_duration = 0 on further segments in case we have any (unlikely)
1349 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1355 finish_decoding_index:
1356 av_free(sorted_segments);
1360 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1362 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1363 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1364 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1365 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1368 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1370 char buf[AV_TIMECODE_STR_SIZE];
1371 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1376 static int mxf_parse_structural_metadata(MXFContext *mxf)
1378 MXFPackage *material_package = NULL;
1379 MXFPackage *temp_package = NULL;
1382 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1383 /* TODO: handle multiple material packages (OP3x) */
1384 for (i = 0; i < mxf->packages_count; i++) {
1385 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1386 if (material_package) break;
1388 if (!material_package) {
1389 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1390 return AVERROR_INVALIDDATA;
1393 for (i = 0; i < material_package->tracks_count; i++) {
1394 MXFPackage *source_package = NULL;
1395 MXFTrack *material_track = NULL;
1396 MXFTrack *source_track = NULL;
1397 MXFTrack *temp_track = NULL;
1398 MXFDescriptor *descriptor = NULL;
1399 MXFStructuralComponent *component = NULL;
1400 MXFTimecodeComponent *mxf_tc = NULL;
1401 UID *essence_container_ul = NULL;
1402 const MXFCodecUL *codec_ul = NULL;
1403 const MXFCodecUL *container_ul = NULL;
1404 const MXFCodecUL *pix_fmt_ul = NULL;
1409 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1410 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1414 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1415 mxf_tc = (MXFTimecodeComponent*)component;
1416 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1417 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1418 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1422 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1423 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1427 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1428 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1432 mxf_tc = (MXFTimecodeComponent*)component;
1433 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1434 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1435 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1440 /* TODO: handle multiple source clips */
1441 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1442 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1446 for (k = 0; k < mxf->packages_count; k++) {
1447 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1450 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1451 source_package = temp_package;
1455 if (!source_package) {
1456 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1459 for (k = 0; k < source_package->tracks_count; k++) {
1460 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1461 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1462 ret = AVERROR_INVALIDDATA;
1465 if (temp_track->track_id == component->source_track_id) {
1466 source_track = temp_track;
1470 if (!source_track) {
1471 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1475 if (!source_track || !component)
1478 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1479 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1480 ret = AVERROR_INVALIDDATA;
1484 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1485 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1486 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1487 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1491 st = avformat_new_stream(mxf->fc, NULL);
1493 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1494 ret = AVERROR(ENOMEM);
1497 st->id = source_track->track_id;
1498 st->priv_data = source_track;
1499 source_track->original_duration = st->duration = component->duration;
1500 if (st->duration == -1)
1501 st->duration = AV_NOPTS_VALUE;
1502 st->start_time = component->start_position;
1503 if (material_track->edit_rate.num <= 0 ||
1504 material_track->edit_rate.den <= 0) {
1505 av_log(mxf->fc, AV_LOG_WARNING,
1506 "Invalid edit rate (%d/%d) found on stream #%d, "
1507 "defaulting to 25/1\n",
1508 material_track->edit_rate.num,
1509 material_track->edit_rate.den, st->index);
1510 material_track->edit_rate = (AVRational){25, 1};
1512 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1514 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1515 * the former is accessible via st->priv_data */
1516 source_track->edit_rate = material_track->edit_rate;
1518 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1519 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1520 st->codec->codec_type = codec_ul->id;
1522 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1523 if (source_package->descriptor) {
1524 if (source_package->descriptor->type == MultipleDescriptor) {
1525 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1526 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1528 if (!sub_descriptor) {
1529 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1532 if (sub_descriptor->linked_track_id == source_track->track_id) {
1533 descriptor = sub_descriptor;
1537 } else if (source_package->descriptor->type == Descriptor)
1538 descriptor = source_package->descriptor;
1541 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1544 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1545 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1546 essence_container_ul = &descriptor->essence_container_ul;
1547 /* HACK: replacing the original key with mxf_encrypted_essence_container
1548 * is not allowed according to s429-6, try to find correct information anyway */
1549 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1550 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1551 for (k = 0; k < mxf->metadata_sets_count; k++) {
1552 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1553 if (metadata->type == CryptoContext) {
1554 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1560 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1561 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1562 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1563 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1564 avcodec_get_name(st->codec->codec_id));
1565 for (k = 0; k < 16; k++) {
1566 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1567 descriptor->essence_codec_ul[k]);
1568 if (!(k+1 & 19) || k == 5)
1569 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1571 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1573 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1574 source_track->intra_only = mxf_is_intra_only(descriptor);
1575 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1576 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1577 st->codec->codec_id = container_ul->id;
1578 st->codec->width = descriptor->width;
1579 st->codec->height = descriptor->height; /* Field height, not frame height */
1580 switch (descriptor->frame_layout) {
1581 case SegmentedFrame:
1582 /* This one is a weird layout I don't fully understand. */
1583 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1586 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1589 /* Every other line is stored and needs to be duplicated. */
1590 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1591 break; /* The correct thing to do here is fall through, but by breaking we might be
1592 able to decode some streams at half the vertical resolution, rather than not al all.
1593 It's also for compatibility with the old behavior. */
1596 case SeparateFields:
1597 switch (descriptor->field_dominance) {
1599 st->codec->field_order = AV_FIELD_TT;
1602 st->codec->field_order = AV_FIELD_BB;
1605 avpriv_request_sample(mxf->fc,
1606 "Field dominance %d support",
1607 descriptor->field_dominance);
1610 /* Turn field height into frame height. */
1611 st->codec->height *= 2;
1614 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1616 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1617 st->codec->pix_fmt = descriptor->pix_fmt;
1618 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1619 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1620 &descriptor->essence_codec_ul);
1621 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1622 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1623 /* support files created before RP224v10 by defaulting to UYVY422
1624 if subsampling is 4:2:2 and component depth is 8-bit */
1625 if (descriptor->horiz_subsampling == 2 &&
1626 descriptor->vert_subsampling == 1 &&
1627 descriptor->component_depth == 8) {
1628 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1633 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1634 if (material_track->sequence->origin) {
1635 char material_origin[3];
1636 snprintf(material_origin, sizeof(material_origin), "%d", material_track->sequence->origin);
1637 av_dict_set(&st->metadata, "material_track_origin", material_origin, 0);
1639 if (source_track->sequence->origin) {
1640 char source_origin[3];
1641 snprintf(source_origin, sizeof(source_origin), "%d", source_track->sequence->origin);
1642 av_dict_set(&st->metadata, "source_track_origin", source_origin, 0);
1644 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1645 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1646 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1647 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))
1648 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1649 st->codec->channels = descriptor->channels;
1650 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1652 if (descriptor->sample_rate.den > 0) {
1653 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1654 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1656 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1657 "found for stream #%d, time base forced to 1/48000\n",
1658 descriptor->sample_rate.num, descriptor->sample_rate.den,
1660 avpriv_set_pts_info(st, 64, 1, 48000);
1663 /* if duration is set, rescale it from EditRate to SampleRate */
1664 if (st->duration != AV_NOPTS_VALUE)
1665 st->duration = av_rescale_q(st->duration,
1666 av_inv_q(material_track->edit_rate),
1669 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1670 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1671 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1672 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1673 else if (descriptor->bits_per_sample == 32)
1674 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1675 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1676 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1677 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1678 else if (descriptor->bits_per_sample == 32)
1679 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1680 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1681 st->need_parsing = AVSTREAM_PARSE_FULL;
1683 } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) {
1684 int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls,
1685 essence_container_ul)->id;
1686 if (codec_id >= 0 &&
1687 codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) {
1688 av_dict_set(&st->metadata, "data_type",
1689 mxf_data_essence_descriptor[codec_id], 0);
1692 if (descriptor->extradata) {
1693 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1694 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1696 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1697 ret = ff_generate_avci_extradata(st);
1701 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1702 /* TODO: decode timestamps */
1703 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1712 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1718 return AVERROR(EINVAL);
1720 buf_size = size + size / 2 + 1;
1721 *str = av_malloc(buf_size);
1723 return AVERROR(ENOMEM);
1725 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1733 static int mxf_uid_to_str(UID uid, char **str)
1737 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1739 return AVERROR(ENOMEM);
1740 for (i = 0; i < sizeof(UID); i++) {
1741 snprintf(p, 2 + 1, "%.2x", uid[i]);
1743 if (i == 3 || i == 5 || i == 7 || i == 9) {
1744 snprintf(p, 1 + 1, "-");
1751 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1753 struct tm time = { 0 };
1754 time.tm_year = (timestamp >> 48) - 1900;
1755 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1756 time.tm_mday = (timestamp >> 32 & 0xFF);
1757 time.tm_hour = (timestamp >> 24 & 0xFF);
1758 time.tm_min = (timestamp >> 16 & 0xFF);
1759 time.tm_sec = (timestamp >> 8 & 0xFF);
1761 /* msvcrt versions of strftime calls the invalid parameter handler
1762 * (aborting the process if one isn't set) if the parameters are out
1764 time.tm_mon = av_clip(time.tm_mon, 0, 11);
1765 time.tm_mday = av_clip(time.tm_mday, 1, 31);
1766 time.tm_hour = av_clip(time.tm_hour, 0, 23);
1767 time.tm_min = av_clip(time.tm_min, 0, 59);
1768 time.tm_sec = av_clip(time.tm_sec, 0, 59);
1770 *str = av_mallocz(32);
1772 return AVERROR(ENOMEM);
1773 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1778 #define SET_STR_METADATA(pb, name, str) do { \
1779 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1781 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1784 #define SET_UID_METADATA(pb, name, var, str) do { \
1785 avio_read(pb, var, 16); \
1786 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1788 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1791 #define SET_TS_METADATA(pb, name, var, str) do { \
1792 var = avio_rb64(pb); \
1793 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1795 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1798 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1800 MXFContext *mxf = arg;
1801 AVFormatContext *s = mxf->fc;
1808 SET_STR_METADATA(pb, "company_name", str);
1811 SET_STR_METADATA(pb, "product_name", str);
1814 SET_STR_METADATA(pb, "product_version", str);
1817 SET_UID_METADATA(pb, "product_uid", uid, str);
1820 SET_TS_METADATA(pb, "modification_date", ts, str);
1823 SET_STR_METADATA(pb, "application_platform", str);
1826 SET_UID_METADATA(pb, "generation_uid", uid, str);
1829 SET_UID_METADATA(pb, "uid", uid, str);
1835 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1836 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1837 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1838 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1839 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1840 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1841 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1842 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1843 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1844 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1845 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1846 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1847 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1848 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1849 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1850 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1851 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1852 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1853 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1854 { { 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 */
1855 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1856 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1857 { { 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 */
1858 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1859 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1860 { { 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 */
1861 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1862 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1863 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1864 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1865 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1866 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1869 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1871 AVIOContext *pb = mxf->fc->pb;
1872 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1873 uint64_t klv_end = avio_tell(pb) + klv->length;
1876 return AVERROR(ENOMEM);
1877 while (avio_tell(pb) + 4 < klv_end && !avio_feof(pb)) {
1879 int tag = avio_rb16(pb);
1880 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1881 uint64_t next = avio_tell(pb) + size;
1884 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1885 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1886 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1889 if (tag > 0x7FFF) { /* dynamic tag */
1891 for (i = 0; i < mxf->local_tags_count; i++) {
1892 int local_tag = AV_RB16(mxf->local_tags+i*18);
1893 if (local_tag == tag) {
1894 memcpy(uid, mxf->local_tags+i*18+2, 16);
1895 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1896 PRINT_KEY(mxf->fc, "uid", uid);
1900 if (ctx_size && tag == 0x3C0A)
1901 avio_read(pb, ctx->uid, 16);
1902 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1905 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1906 * it extending past the end of the KLV though (zzuf5.mxf). */
1907 if (avio_tell(pb) > klv_end) {
1911 av_log(mxf->fc, AV_LOG_ERROR,
1912 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1914 return AVERROR_INVALIDDATA;
1915 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1916 avio_seek(pb, next, SEEK_SET);
1918 if (ctx_size) ctx->type = type;
1919 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1923 * Seeks to the previous partition, if possible
1924 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1926 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1928 AVIOContext *pb = mxf->fc->pb;
1930 if (!mxf->current_partition ||
1931 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1932 return 0; /* we've parsed all partitions */
1934 /* seek to previous partition */
1935 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1936 mxf->current_partition = NULL;
1938 av_dlog(mxf->fc, "seeking to previous partition\n");
1944 * Called when essence is encountered
1945 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1947 static int mxf_parse_handle_essence(MXFContext *mxf)
1949 AVIOContext *pb = mxf->fc->pb;
1952 if (mxf->parsing_backward) {
1953 return mxf_seek_to_previous_partition(mxf);
1955 uint64_t offset = mxf->footer_partition ? mxf->footer_partition
1956 : mxf->last_partition;
1959 av_dlog(mxf->fc, "no last partition\n");
1963 av_dlog(mxf->fc, "seeking to last partition\n");
1965 /* remember where we were so we don't end up seeking further back than this */
1966 mxf->last_forward_tell = avio_tell(pb);
1968 if (!pb->seekable) {
1969 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1973 /* seek to last partition and parse backward */
1974 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1975 av_log(mxf->fc, AV_LOG_ERROR,
1976 "failed to seek to last partition @ 0x%" PRIx64
1977 " (%"PRId64") - partial file?\n",
1978 mxf->run_in + offset, ret);
1982 mxf->current_partition = NULL;
1983 mxf->parsing_backward = 1;
1990 * Called when the next partition or EOF is encountered
1991 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1993 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1995 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1999 * Figures out the proper offset and length of the essence container in each partition
2001 static void mxf_compute_essence_containers(MXFContext *mxf)
2005 /* everything is already correct */
2006 if (mxf->op == OPAtom)
2009 for (x = 0; x < mxf->partitions_count; x++) {
2010 MXFPartition *p = &mxf->partitions[x];
2013 continue; /* BodySID == 0 -> no essence */
2015 if (x >= mxf->partitions_count - 1)
2016 break; /* last partition - can't compute length (and we don't need to) */
2018 /* essence container spans to the next partition */
2019 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
2021 if (p->essence_length < 0) {
2022 /* next ThisPartition < essence_offset */
2023 p->essence_length = 0;
2024 av_log(mxf->fc, AV_LOG_ERROR,
2025 "partition %i: bad ThisPartition = %"PRIX64"\n",
2026 x+1, mxf->partitions[x+1].this_partition);
2031 static int64_t round_to_kag(int64_t position, int kag_size)
2033 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2034 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2035 int64_t ret = (position / kag_size) * kag_size;
2036 return ret == position ? ret : ret + kag_size;
2039 static int is_pcm(enum AVCodecID codec_id)
2041 /* we only care about "normal" PCM codecs until we get samples */
2042 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2046 * Deal with the case where for some audio atoms EditUnitByteCount is
2047 * very small (2, 4..). In those cases we should read more than one
2048 * sample per call to mxf_read_packet().
2050 static void mxf_handle_small_eubc(AVFormatContext *s)
2052 MXFContext *mxf = s->priv_data;
2054 /* assuming non-OPAtom == frame wrapped
2055 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2056 if (mxf->op != OPAtom)
2059 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2060 if (s->nb_streams != 1 ||
2061 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2062 !is_pcm(s->streams[0]->codec->codec_id) ||
2063 mxf->nb_index_tables != 1 ||
2064 mxf->index_tables[0].nb_segments != 1 ||
2065 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2068 /* arbitrarily default to 48 kHz PAL audio frame size */
2069 /* TODO: We could compute this from the ratio between the audio
2070 * and video edit rates for 48 kHz NTSC we could use the
2071 * 1802-1802-1802-1802-1801 pattern. */
2072 mxf->edit_units_per_packet = 1920;
2075 static void mxf_read_random_index_pack(AVFormatContext *s)
2077 MXFContext *mxf = s->priv_data;
2082 if (!s->pb->seekable)
2085 file_size = avio_size(s->pb);
2086 avio_seek(s->pb, file_size - 4, SEEK_SET);
2087 length = avio_rb32(s->pb);
2088 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2090 avio_seek(s->pb, file_size - length, SEEK_SET);
2091 if (klv_read_packet(&klv, s->pb) < 0 ||
2092 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2093 klv.length != length - 20)
2096 avio_skip(s->pb, klv.length - 12);
2097 mxf->last_partition = avio_rb64(s->pb);
2100 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2103 static int mxf_read_header(AVFormatContext *s)
2105 MXFContext *mxf = s->priv_data;
2107 int64_t essence_offset = 0;
2108 int64_t last_pos = -1;
2109 uint64_t last_pos_index = 1;
2112 mxf->last_forward_tell = INT64_MAX;
2113 mxf->edit_units_per_packet = 1;
2115 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2116 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2117 return AVERROR_INVALIDDATA;
2119 avio_seek(s->pb, -14, SEEK_CUR);
2121 mxf->run_in = avio_tell(s->pb);
2123 mxf_read_random_index_pack(s);
2125 while (!avio_feof(s->pb)) {
2126 const MXFMetadataReadTableEntry *metadata;
2127 if (avio_tell(s->pb) == last_pos) {
2128 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2129 return AVERROR_INVALIDDATA;
2131 if ((1ULL<<61) % last_pos_index++ == 0)
2132 last_pos = avio_tell(s->pb);
2133 if (klv_read_packet(&klv, s->pb) < 0) {
2134 /* EOF - seek to previous partition or stop */
2135 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2141 PRINT_KEY(s, "read header", klv.key);
2142 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2143 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2144 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2145 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2146 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2148 if (!mxf->current_partition) {
2149 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2150 return AVERROR_INVALIDDATA;
2153 if (!mxf->current_partition->essence_offset) {
2154 /* for OP1a we compute essence_offset
2155 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2156 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2157 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2159 int64_t op1a_essence_offset =
2160 round_to_kag(mxf->current_partition->this_partition +
2161 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2162 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2163 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2165 if (mxf->op == OPAtom) {
2166 /* point essence_offset to the actual data
2167 * OPAtom has all the essence in one big KLV
2169 mxf->current_partition->essence_offset = avio_tell(s->pb);
2170 mxf->current_partition->essence_length = klv.length;
2172 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2173 mxf->current_partition->essence_offset = op1a_essence_offset;
2177 if (!essence_offset)
2178 essence_offset = klv.offset;
2180 /* seek to footer, previous partition or stop */
2181 if (mxf_parse_handle_essence(mxf) <= 0)
2184 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2185 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2186 /* next partition pack - keep going, seek to previous partition or stop */
2187 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2189 else if (mxf->parsing_backward)
2191 /* we're still parsing forward. proceed to parsing this partition pack */
2194 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2195 if (IS_KLV_KEY(klv.key, metadata->key)) {
2197 if (klv.key[5] == 0x53) {
2198 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2200 uint64_t next = avio_tell(s->pb) + klv.length;
2201 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2203 /* only seek forward, else this can loop for a long time */
2204 if (avio_tell(s->pb) > next) {
2205 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2207 return AVERROR_INVALIDDATA;
2210 avio_seek(s->pb, next, SEEK_SET);
2213 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2219 if (!metadata->read)
2220 avio_skip(s->pb, klv.length);
2222 /* FIXME avoid seek */
2223 if (!essence_offset) {
2224 av_log(s, AV_LOG_ERROR, "no essence\n");
2225 return AVERROR_INVALIDDATA;
2227 avio_seek(s->pb, essence_offset, SEEK_SET);
2229 mxf_compute_essence_containers(mxf);
2231 /* we need to do this before computing the index tables
2232 * to be able to fill in zero IndexDurations with st->duration */
2233 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2236 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2239 if (mxf->nb_index_tables > 1) {
2240 /* TODO: look up which IndexSID to use via EssenceContainerData */
2241 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2242 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2243 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2244 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2245 ret = AVERROR_INVALIDDATA;
2249 mxf_handle_small_eubc(s);
2259 * Sets mxf->current_edit_unit based on what offset we're currently at.
2260 * @return next_ofs if OK, <0 on error
2262 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2264 int64_t last_ofs = -1, next_ofs = -1;
2265 MXFIndexTable *t = &mxf->index_tables[0];
2267 /* this is called from the OP1a demuxing logic, which means there
2268 * may be no index tables */
2269 if (mxf->nb_index_tables <= 0)
2272 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2273 while (mxf->current_edit_unit >= 0) {
2274 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2277 if (next_ofs <= last_ofs) {
2278 /* large next_ofs didn't change or current_edit_unit wrapped
2279 * around this fixes the infinite loop on zzuf3.mxf */
2280 av_log(mxf->fc, AV_LOG_ERROR,
2281 "next_ofs didn't change. not deriving packet timestamps\n");
2285 if (next_ofs > current_offset)
2288 last_ofs = next_ofs;
2289 mxf->current_edit_unit++;
2292 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2293 if (mxf->current_edit_unit < 0)
2299 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2300 uint64_t *sample_count)
2302 int i, total = 0, size = 0;
2303 AVStream *st = mxf->fc->streams[stream_index];
2304 MXFTrack *track = st->priv_data;
2305 AVRational time_base = av_inv_q(track->edit_rate);
2306 AVRational sample_rate = av_inv_q(st->time_base);
2307 const MXFSamplesPerFrame *spf = NULL;
2309 if ((sample_rate.num / sample_rate.den) == 48000)
2310 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2312 int remainder = (sample_rate.num * time_base.num) %
2313 (time_base.den * sample_rate.den);
2314 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2315 av_mul_q(sample_rate, time_base)));
2317 av_log(mxf->fc, AV_LOG_WARNING,
2318 "seeking detected on stream #%d with time base (%d/%d) and "
2319 "sample rate (%d/%d), audio pts won't be accurate.\n",
2320 stream_index, time_base.num, time_base.den,
2321 sample_rate.num, sample_rate.den);
2325 while (spf->samples_per_frame[size]) {
2326 total += spf->samples_per_frame[size];
2332 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2333 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2334 *sample_count += spf->samples_per_frame[i];
2340 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2343 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2344 int64_t bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2346 pkt->pts = track->sample_count;
2348 if ( codec->channels <= 0
2349 || bits_per_sample <= 0
2350 || codec->channels * (int64_t)bits_per_sample < 8)
2351 return AVERROR(EINVAL);
2352 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2356 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2359 MXFContext *mxf = s->priv_data;
2362 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2363 PRINT_KEY(s, "read packet", klv.key);
2364 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2365 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2366 ret = mxf_decrypt_triplet(s, pkt, &klv);
2368 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2373 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2374 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2375 int index = mxf_get_stream_index(s, &klv);
2376 int64_t next_ofs, next_klv;
2379 AVCodecContext *codec;
2382 av_log(s, AV_LOG_ERROR,
2383 "error getting stream index %"PRIu32"\n",
2384 AV_RB32(klv.key + 12));
2388 st = s->streams[index];
2389 track = st->priv_data;
2391 if (s->streams[index]->discard == AVDISCARD_ALL)
2394 next_klv = avio_tell(s->pb) + klv.length;
2395 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2397 if (next_ofs >= 0 && next_klv > next_ofs) {
2398 /* if this check is hit then it's possible OPAtom was treated as OP1a
2399 * truncate the packet since it's probably very large (>2 GiB is common) */
2400 avpriv_request_sample(s,
2401 "OPAtom misinterpreted as OP1a?"
2402 "KLV for edit unit %i extending into "
2404 mxf->current_edit_unit);
2405 klv.length = next_ofs - avio_tell(s->pb);
2408 /* check for 8 channels AES3 element */
2409 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2410 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2413 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2417 ret = av_get_packet(s->pb, pkt, klv.length);
2421 pkt->stream_index = index;
2422 pkt->pos = klv.offset;
2424 codec = s->streams[index]->codec;
2426 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2427 /* mxf->current_edit_unit good - see if we have an
2428 * index table to derive timestamps from */
2429 MXFIndexTable *t = &mxf->index_tables[0];
2431 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2432 pkt->dts = mxf->current_edit_unit + t->first_dts;
2433 pkt->pts = t->ptses[mxf->current_edit_unit];
2434 } else if (track->intra_only) {
2435 /* intra-only -> PTS = EditUnit.
2436 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2437 pkt->pts = mxf->current_edit_unit;
2439 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2440 ret = mxf_set_audio_pts(mxf, codec, pkt);
2445 /* seek for truncated packets */
2446 avio_seek(s->pb, next_klv, SEEK_SET);
2451 avio_skip(s->pb, klv.length);
2453 return avio_feof(s->pb) ? AVERROR_EOF : ret;
2456 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2458 MXFContext *mxf = s->priv_data;
2460 int64_t ret64, pos, next_pos;
2465 if (mxf->op != OPAtom)
2466 return mxf_read_packet_old(s, pkt);
2468 /* OPAtom - clip wrapped demuxing */
2469 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2471 t = &mxf->index_tables[0];
2473 if (mxf->current_edit_unit >= st->duration)
2476 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2478 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2481 /* compute size by finding the next edit unit or the end of the essence container
2482 * not pretty, but it works */
2483 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2484 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2485 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2486 return AVERROR_INVALIDDATA;
2489 if ((size = next_pos - pos) <= 0) {
2490 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2491 return AVERROR_INVALIDDATA;
2494 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2497 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2500 pkt->stream_index = 0;
2502 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2503 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2504 pkt->dts = mxf->current_edit_unit + t->first_dts;
2505 pkt->pts = t->ptses[mxf->current_edit_unit];
2506 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2507 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2512 mxf->current_edit_unit += edit_units;
2517 static int mxf_read_close(AVFormatContext *s)
2519 MXFContext *mxf = s->priv_data;
2520 MXFIndexTableSegment *seg;
2523 av_freep(&mxf->packages_refs);
2525 for (i = 0; i < s->nb_streams; i++)
2526 s->streams[i]->priv_data = NULL;
2528 for (i = 0; i < mxf->metadata_sets_count; i++) {
2529 switch (mxf->metadata_sets[i]->type) {
2531 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2533 case MultipleDescriptor:
2534 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2537 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2540 case MaterialPackage:
2541 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2543 case IndexTableSegment:
2544 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2545 av_freep(&seg->temporal_offset_entries);
2546 av_freep(&seg->flag_entries);
2547 av_freep(&seg->stream_offset_entries);
2552 av_freep(&mxf->metadata_sets[i]);
2554 av_freep(&mxf->partitions);
2555 av_freep(&mxf->metadata_sets);
2556 av_freep(&mxf->aesc);
2557 av_freep(&mxf->local_tags);
2559 if (mxf->index_tables) {
2560 for (i = 0; i < mxf->nb_index_tables; i++) {
2561 av_freep(&mxf->index_tables[i].segments);
2562 av_freep(&mxf->index_tables[i].ptses);
2563 av_freep(&mxf->index_tables[i].fake_index);
2566 av_freep(&mxf->index_tables);
2571 static int mxf_probe(AVProbeData *p) {
2572 const uint8_t *bufp = p->buf;
2573 const uint8_t *end = p->buf + p->buf_size;
2575 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2578 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2579 end -= sizeof(mxf_header_partition_pack_key);
2581 for (; bufp < end;) {
2582 if (!((bufp[13] - 1) & 0xF2)){
2583 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2584 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2585 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2586 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2587 return AVPROBE_SCORE_MAX;
2596 /* rudimentary byte seek */
2597 /* XXX: use MXF Index */
2598 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2600 AVStream *st = s->streams[stream_index];
2602 MXFContext* mxf = s->priv_data;
2606 MXFTrack *source_track = st->priv_data;
2608 /* if audio then truncate sample_time to EditRate */
2609 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2610 sample_time = av_rescale_q(sample_time, st->time_base,
2611 av_inv_q(source_track->edit_rate));
2613 if (mxf->nb_index_tables <= 0) {
2615 return AVERROR_INVALIDDATA;
2616 if (sample_time < 0)
2618 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2620 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2624 ff_update_cur_dts(s, st, sample_time);
2625 mxf->current_edit_unit = sample_time;
2627 t = &mxf->index_tables[0];
2629 /* clamp above zero, else ff_index_search_timestamp() returns negative
2630 * this also means we allow seeking before the start */
2631 sample_time = FFMAX(sample_time, 0);
2633 if (t->fake_index) {
2634 /* behave as if we have a proper index */
2635 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2638 /* no IndexEntryArray (one or more CBR segments)
2639 * make sure we don't seek past the end */
2640 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2643 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2646 ff_update_cur_dts(s, st, sample_time);
2647 mxf->current_edit_unit = sample_time;
2648 avio_seek(s->pb, seekpos, SEEK_SET);
2651 // Update all tracks sample count
2652 for (i = 0; i < s->nb_streams; i++) {
2653 AVStream *cur_st = s->streams[i];
2654 MXFTrack *cur_track = cur_st->priv_data;
2655 uint64_t current_sample_count = 0;
2656 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2657 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2661 cur_track->sample_count = current_sample_count;
2667 AVInputFormat ff_mxf_demuxer = {
2669 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2670 .priv_data_size = sizeof(MXFContext),
2671 .read_probe = mxf_probe,
2672 .read_header = mxf_read_header,
2673 .read_packet = mxf_read_packet,
2674 .read_close = mxf_read_close,
2675 .read_seek = mxf_read_seek,