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;
121 enum MXFMetadataSetType type;
124 struct AVRational rate;
126 } MXFTimecodeComponent;
130 enum MXFMetadataSetType type;
131 MXFSequence *sequence; /* mandatory, and only one */
134 uint8_t track_number[4];
135 AVRational edit_rate;
137 uint64_t sample_count;
138 int64_t original_duration; /* st->duration in SampleRate/EditRate units */
143 enum MXFMetadataSetType type;
144 UID essence_container_ul;
145 UID essence_codec_ul;
146 AVRational sample_rate;
147 AVRational aspect_ratio;
149 int height; /* Field height, not frame height */
150 int frame_layout; /* See MXFFrameLayout enum */
156 unsigned int component_depth;
157 unsigned int horiz_subsampling;
158 unsigned int vert_subsampling;
159 UID *sub_descriptors_refs;
160 int sub_descriptors_count;
164 enum AVPixelFormat pix_fmt;
169 enum MXFMetadataSetType type;
170 int edit_unit_byte_count;
173 AVRational index_edit_rate;
174 uint64_t index_start_position;
175 uint64_t index_duration;
176 int8_t *temporal_offset_entries;
178 uint64_t *stream_offset_entries;
179 int nb_index_entries;
180 } MXFIndexTableSegment;
184 enum MXFMetadataSetType type;
188 MXFDescriptor *descriptor; /* only one */
194 enum MXFMetadataSetType type;
197 /* decoded index table */
201 int nb_ptses; /* number of PTSes or total duration of index */
202 int64_t first_dts; /* DTS = EditUnit + first_dts */
203 int64_t *ptses; /* maps EditUnit -> PTS */
205 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
206 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
210 MXFPartition *partitions;
211 unsigned partitions_count;
215 MXFMetadataSet **metadata_sets;
216 int metadata_sets_count;
220 int local_tags_count;
221 uint64_t last_partition;
222 uint64_t footer_partition;
223 KLVPacket current_klv_data;
224 int current_klv_index;
226 MXFPartition *current_partition;
227 int parsing_backward;
228 int64_t last_forward_tell;
229 int last_forward_partition;
230 int current_edit_unit;
232 MXFIndexTable *index_tables;
233 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
236 enum MXFWrappingScheme {
241 /* NOTE: klv_offset is not set (-1) for local keys */
242 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
246 MXFMetadataReadFunc *read;
248 enum MXFMetadataSetType type;
249 } MXFMetadataReadTableEntry;
251 static int mxf_read_close(AVFormatContext *s);
253 /* partial keys to match */
254 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
255 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
256 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
257 static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 };
258 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
259 /* complete keys to match */
260 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 };
261 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
262 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
263 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 };
264 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
266 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
268 static int64_t klv_decode_ber_length(AVIOContext *pb)
270 uint64_t size = avio_r8(pb);
271 if (size & 0x80) { /* long form */
272 int bytes_num = size & 0x7f;
273 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
275 return AVERROR_INVALIDDATA;
278 size = size << 8 | avio_r8(pb);
283 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
286 for (i = 0; i < size && !url_feof(pb); i++) {
290 else if (b != key[i])
296 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
298 if (!mxf_read_sync(pb, mxf_klv_key, 4))
299 return AVERROR_INVALIDDATA;
300 klv->offset = avio_tell(pb) - 4;
301 memcpy(klv->key, mxf_klv_key, 4);
302 avio_read(pb, klv->key + 4, 12);
303 klv->length = klv_decode_ber_length(pb);
304 return klv->length == -1 ? -1 : 0;
307 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
311 for (i = 0; i < s->nb_streams; i++) {
312 MXFTrack *track = s->streams[i]->priv_data;
314 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
317 /* return 0 if only one stream, for OP Atom files with 0 as track number */
318 return s->nb_streams == 1 ? 0 : -1;
321 /* XXX: use AVBitStreamFilter */
322 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
324 const uint8_t *buf_ptr, *end_ptr;
328 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
329 return AVERROR_INVALIDDATA;
330 length = av_get_packet(pb, pkt, length);
333 data_ptr = pkt->data;
334 end_ptr = pkt->data + length;
335 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
336 for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
337 for (i = 0; i < st->codec->channels; i++) {
338 uint32_t sample = bytestream_get_le32(&buf_ptr);
339 if (st->codec->bits_per_coded_sample == 24)
340 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
342 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
344 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
346 av_shrink_packet(pkt, data_ptr - pkt->data);
350 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
352 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
353 MXFContext *mxf = s->priv_data;
354 AVIOContext *pb = s->pb;
355 int64_t end = avio_tell(pb) + klv->length;
358 uint64_t plaintext_size;
363 if (!mxf->aesc && s->key && s->keylen == 16) {
364 mxf->aesc = av_aes_alloc();
366 return AVERROR(ENOMEM);
367 av_aes_init(mxf->aesc, s->key, 128, 1);
370 avio_skip(pb, klv_decode_ber_length(pb));
372 klv_decode_ber_length(pb);
373 plaintext_size = avio_rb64(pb);
375 klv_decode_ber_length(pb);
376 avio_read(pb, klv->key, 16);
377 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
378 return AVERROR_INVALIDDATA;
379 index = mxf_get_stream_index(s, klv);
381 return AVERROR_INVALIDDATA;
383 klv_decode_ber_length(pb);
384 orig_size = avio_rb64(pb);
385 if (orig_size < plaintext_size)
386 return AVERROR_INVALIDDATA;
388 size = klv_decode_ber_length(pb);
389 if (size < 32 || size - 32 < orig_size)
390 return AVERROR_INVALIDDATA;
391 avio_read(pb, ivec, 16);
392 avio_read(pb, tmpbuf, 16);
394 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
395 if (memcmp(tmpbuf, checkv, 16))
396 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
398 size = av_get_packet(pb, pkt, size);
401 else if (size < plaintext_size)
402 return AVERROR_INVALIDDATA;
403 size -= plaintext_size;
405 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
406 &pkt->data[plaintext_size], size >> 4, ivec, 1);
407 av_shrink_packet(pkt, orig_size);
408 pkt->stream_index = index;
409 avio_skip(pb, end - avio_tell(pb));
413 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
415 MXFContext *mxf = arg;
416 int item_num = avio_rb32(pb);
417 int item_len = avio_rb32(pb);
419 if (item_len != 18) {
420 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
421 return AVERROR_PATCHWELCOME;
423 if (item_num > 65536) {
424 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
425 return AVERROR_INVALIDDATA;
427 mxf->local_tags = av_calloc(item_num, item_len);
428 if (!mxf->local_tags)
429 return AVERROR(ENOMEM);
430 mxf->local_tags_count = item_num;
431 avio_read(pb, mxf->local_tags, item_num*item_len);
435 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
437 MXFContext *mxf = arg;
438 MXFPartition *partition, *tmp_part;
440 uint64_t footer_partition;
441 uint32_t nb_essence_containers;
443 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
445 return AVERROR(ENOMEM);
446 mxf->partitions = tmp_part;
448 if (mxf->parsing_backward) {
449 /* insert the new partition pack in the middle
450 * this makes the entries in mxf->partitions sorted by offset */
451 memmove(&mxf->partitions[mxf->last_forward_partition+1],
452 &mxf->partitions[mxf->last_forward_partition],
453 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
454 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
456 mxf->last_forward_partition++;
457 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
460 memset(partition, 0, sizeof(*partition));
461 mxf->partitions_count++;
462 partition->pack_length = avio_tell(pb) - klv_offset + size;
466 partition->type = Header;
469 partition->type = BodyPartition;
472 partition->type = Footer;
475 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
476 return AVERROR_INVALIDDATA;
479 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
480 partition->closed = partition->type == Footer || !(uid[14] & 1);
481 partition->complete = uid[14] > 2;
483 partition->kag_size = avio_rb32(pb);
484 partition->this_partition = avio_rb64(pb);
485 partition->previous_partition = avio_rb64(pb);
486 footer_partition = avio_rb64(pb);
487 partition->header_byte_count = avio_rb64(pb);
488 partition->index_byte_count = avio_rb64(pb);
489 partition->index_sid = avio_rb32(pb);
491 partition->body_sid = avio_rb32(pb);
492 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
493 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
494 return AVERROR_INVALIDDATA;
496 nb_essence_containers = avio_rb32(pb);
498 if (partition->this_partition &&
499 partition->previous_partition == partition->this_partition) {
500 av_log(mxf->fc, AV_LOG_ERROR,
501 "PreviousPartition equal to ThisPartition %"PRIx64"\n",
502 partition->previous_partition);
503 /* override with the actual previous partition offset */
504 if (!mxf->parsing_backward && mxf->last_forward_partition > 1) {
506 mxf->partitions + mxf->last_forward_partition - 2;
507 partition->previous_partition = prev->this_partition;
509 /* if no previous body partition are found point to the header
511 if (partition->previous_partition == partition->this_partition)
512 partition->previous_partition = 0;
513 av_log(mxf->fc, AV_LOG_ERROR,
514 "Overriding PreviousPartition with %"PRIx64"\n",
515 partition->previous_partition);
518 /* some files don'thave FooterPartition set in every partition */
519 if (footer_partition) {
520 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
521 av_log(mxf->fc, AV_LOG_ERROR,
522 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
523 mxf->footer_partition, footer_partition);
525 mxf->footer_partition = footer_partition;
530 "PartitionPack: ThisPartition = 0x%"PRIX64
531 ", PreviousPartition = 0x%"PRIX64", "
532 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
533 partition->this_partition,
534 partition->previous_partition, footer_partition,
535 partition->index_sid, partition->body_sid);
537 /* sanity check PreviousPartition if set */
538 if (partition->previous_partition &&
539 mxf->run_in + partition->previous_partition >= klv_offset) {
540 av_log(mxf->fc, AV_LOG_ERROR,
541 "PreviousPartition points to this partition or forward\n");
542 return AVERROR_INVALIDDATA;
545 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
546 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
547 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
548 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
549 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
550 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
551 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
552 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
553 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
554 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
555 else if (op[12] == 0x10) {
556 /* SMPTE 390m: "There shall be exactly one essence container"
557 * The following block deals with files that violate this, namely:
558 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
559 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
560 if (nb_essence_containers != 1) {
561 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
565 av_log(mxf->fc, AV_LOG_WARNING,
566 "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n",
567 nb_essence_containers,
568 op == OP1a ? "OP1a" : "OPAtom");
574 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
578 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
579 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ",
580 partition->kag_size);
582 if (mxf->op == OPSONYOpt)
583 partition->kag_size = 512;
585 partition->kag_size = 1;
587 av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size);
593 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
595 MXFMetadataSet **tmp;
597 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
599 return AVERROR(ENOMEM);
600 mxf->metadata_sets = tmp;
601 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
602 mxf->metadata_sets_count++;
606 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
608 MXFCryptoContext *cryptocontext = arg;
610 return AVERROR_INVALIDDATA;
611 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
612 avio_read(pb, cryptocontext->source_container_ul, 16);
616 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
618 MXFContext *mxf = arg;
621 mxf->packages_count = avio_rb32(pb);
622 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
623 if (!mxf->packages_refs)
624 return AVERROR(ENOMEM);
625 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
626 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
632 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
634 MXFStructuralComponent *source_clip = arg;
637 source_clip->duration = avio_rb64(pb);
640 source_clip->start_position = avio_rb64(pb);
643 /* UMID, only get last 16 bytes */
645 avio_read(pb, source_clip->source_package_uid, 16);
648 source_clip->source_track_id = avio_rb32(pb);
654 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
656 MXFPackage *package = arg;
659 package->tracks_count = avio_rb32(pb);
660 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
661 if (!package->tracks_refs)
662 return AVERROR(ENOMEM);
663 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
664 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
670 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
672 MXFTimecodeComponent *mxf_timecode = arg;
675 mxf_timecode->start_frame = avio_rb64(pb);
678 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
681 mxf_timecode->drop_frame = avio_r8(pb);
687 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
689 MXFTrack *track = arg;
692 track->track_id = avio_rb32(pb);
695 avio_read(pb, track->track_number, 4);
698 track->edit_rate.num = avio_rb32(pb);
699 track->edit_rate.den = avio_rb32(pb);
702 avio_read(pb, track->sequence_ref, 16);
708 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
710 MXFSequence *sequence = arg;
713 sequence->duration = avio_rb64(pb);
716 avio_read(pb, sequence->data_definition_ul, 16);
719 sequence->structural_components_count = avio_rb32(pb);
720 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
721 if (!sequence->structural_components_refs)
722 return AVERROR(ENOMEM);
723 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
724 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
730 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
732 MXFPackage *package = arg;
735 package->tracks_count = avio_rb32(pb);
736 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
737 if (!package->tracks_refs)
738 return AVERROR(ENOMEM);
739 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
740 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
743 /* UMID, only get last 16 bytes */
745 avio_read(pb, package->package_uid, 16);
748 avio_read(pb, package->descriptor_ref, 16);
754 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
758 segment->nb_index_entries = avio_rb32(pb);
760 length = avio_rb32(pb);
762 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
763 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
764 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
765 return AVERROR(ENOMEM);
767 for (i = 0; i < segment->nb_index_entries; i++) {
768 segment->temporal_offset_entries[i] = avio_r8(pb);
769 avio_r8(pb); /* KeyFrameOffset */
770 segment->flag_entries[i] = avio_r8(pb);
771 segment->stream_offset_entries[i] = avio_rb64(pb);
772 avio_skip(pb, length - 11);
777 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
779 MXFIndexTableSegment *segment = arg;
782 segment->edit_unit_byte_count = avio_rb32(pb);
783 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
786 segment->index_sid = avio_rb32(pb);
787 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
790 segment->body_sid = avio_rb32(pb);
791 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
794 av_dlog(NULL, "IndexEntryArray found\n");
795 return mxf_read_index_entry_array(pb, segment);
797 segment->index_edit_rate.num = avio_rb32(pb);
798 segment->index_edit_rate.den = avio_rb32(pb);
799 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
800 segment->index_edit_rate.den);
803 segment->index_start_position = avio_rb64(pb);
804 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
807 segment->index_duration = avio_rb64(pb);
808 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
814 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
816 int code, value, ofs = 0;
817 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
822 av_dlog(NULL, "pixel layout: code %#x\n", code);
825 layout[ofs++] = code;
826 layout[ofs++] = value;
828 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
829 } while (code != 0); /* SMPTE 377M E.2.46 */
831 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
834 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
836 MXFDescriptor *descriptor = arg;
837 descriptor->pix_fmt = AV_PIX_FMT_NONE;
840 descriptor->sub_descriptors_count = avio_rb32(pb);
841 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
842 if (!descriptor->sub_descriptors_refs)
843 return AVERROR(ENOMEM);
844 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
845 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
848 avio_read(pb, descriptor->essence_container_ul, 16);
851 descriptor->linked_track_id = avio_rb32(pb);
853 case 0x3201: /* PictureEssenceCoding */
854 avio_read(pb, descriptor->essence_codec_ul, 16);
857 descriptor->width = avio_rb32(pb);
860 descriptor->height = avio_rb32(pb);
863 descriptor->frame_layout = avio_r8(pb);
866 descriptor->aspect_ratio.num = avio_rb32(pb);
867 descriptor->aspect_ratio.den = avio_rb32(pb);
870 descriptor->field_dominance = avio_r8(pb);
873 descriptor->component_depth = avio_rb32(pb);
876 descriptor->horiz_subsampling = avio_rb32(pb);
879 descriptor->vert_subsampling = avio_rb32(pb);
882 descriptor->sample_rate.num = avio_rb32(pb);
883 descriptor->sample_rate.den = avio_rb32(pb);
885 case 0x3D06: /* SoundEssenceCompression */
886 avio_read(pb, descriptor->essence_codec_ul, 16);
889 descriptor->channels = avio_rb32(pb);
892 descriptor->bits_per_sample = avio_rb32(pb);
895 mxf_read_pixel_layout(pb, descriptor);
898 /* Private uid used by SONY C0023S01.mxf */
899 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
900 if (descriptor->extradata)
901 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
902 av_free(descriptor->extradata);
903 descriptor->extradata_size = 0;
904 descriptor->extradata = av_malloc(size);
905 if (!descriptor->extradata)
906 return AVERROR(ENOMEM);
907 descriptor->extradata_size = size;
908 avio_read(pb, descriptor->extradata, size);
916 * Match an uid independently of the version byte and up to len common bytes
919 static int mxf_match_uid(const UID key, const UID uid, int len)
922 for (i = 0; i < len; i++) {
923 if (i != 7 && key[i] != uid[i])
929 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
931 while (uls->uid[0]) {
932 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
939 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
945 for (i = 0; i < mxf->metadata_sets_count; i++) {
946 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
947 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
948 return mxf->metadata_sets[i];
954 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
955 // video essence container uls
956 { { 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 */
957 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
958 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
959 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
962 /* EC ULs for intra-only formats */
963 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
964 { { 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 */
965 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
968 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
969 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
970 { { 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 */
971 { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
972 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
975 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
976 // sound essence container uls
977 { { 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 */
978 { { 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 */
979 { { 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 */
980 { { 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 */
981 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
984 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
986 int i, j, nb_segments = 0;
987 MXFIndexTableSegment **unsorted_segments;
988 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
990 /* count number of segments, allocate arrays and copy unsorted segments */
991 for (i = 0; i < mxf->metadata_sets_count; i++)
992 if (mxf->metadata_sets[i]->type == IndexTableSegment)
996 return AVERROR_INVALIDDATA;
998 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
999 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
1000 av_freep(sorted_segments);
1001 av_free(unsorted_segments);
1002 return AVERROR(ENOMEM);
1005 for (i = j = 0; i < mxf->metadata_sets_count; i++)
1006 if (mxf->metadata_sets[i]->type == IndexTableSegment)
1007 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
1009 *nb_sorted_segments = 0;
1011 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
1012 for (i = 0; i < nb_segments; i++) {
1013 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
1014 uint64_t best_index_duration = 0;
1016 for (j = 0; j < nb_segments; j++) {
1017 MXFIndexTableSegment *s = unsorted_segments[j];
1019 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
1020 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
1021 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1023 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1024 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1025 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1027 best_body_sid = s->body_sid;
1028 best_index_sid = s->index_sid;
1029 best_index_start = s->index_start_position;
1030 best_index_duration = s->index_duration;
1034 /* no suitable entry found -> we're done */
1038 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1039 last_body_sid = best_body_sid;
1040 last_index_sid = best_index_sid;
1041 last_index_start = best_index_start;
1044 av_free(unsorted_segments);
1050 * Computes the absolute file offset of the given essence container offset
1052 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1055 int64_t offset_in = offset; /* for logging */
1057 for (x = 0; x < mxf->partitions_count; x++) {
1058 MXFPartition *p = &mxf->partitions[x];
1060 if (p->body_sid != body_sid)
1063 if (offset < p->essence_length || !p->essence_length) {
1064 *offset_out = p->essence_offset + offset;
1068 offset -= p->essence_length;
1071 av_log(mxf->fc, AV_LOG_ERROR,
1072 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1073 offset_in, body_sid);
1075 return AVERROR_INVALIDDATA;
1079 * Returns the end position of the essence container with given BodySID, or zero if unknown
1081 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1086 for (x = 0; x < mxf->partitions_count; x++) {
1087 MXFPartition *p = &mxf->partitions[x];
1089 if (p->body_sid != body_sid)
1092 if (!p->essence_length)
1095 ret = p->essence_offset + p->essence_length;
1101 /* EditUnit -> absolute offset */
1102 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)
1105 int64_t offset_temp = 0;
1107 for (i = 0; i < index_table->nb_segments; i++) {
1108 MXFIndexTableSegment *s = index_table->segments[i];
1110 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1112 if (edit_unit < s->index_start_position + s->index_duration) {
1113 int64_t index = edit_unit - s->index_start_position;
1115 if (s->edit_unit_byte_count)
1116 offset_temp += s->edit_unit_byte_count * index;
1117 else if (s->nb_index_entries) {
1118 if (s->nb_index_entries == 2 * s->index_duration + 1)
1119 index *= 2; /* Avid index */
1121 if (index < 0 || index >= s->nb_index_entries) {
1122 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1123 index_table->index_sid, s->index_start_position);
1124 return AVERROR_INVALIDDATA;
1127 offset_temp = s->stream_offset_entries[index];
1129 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1130 index_table->index_sid, s->index_start_position);
1131 return AVERROR_INVALIDDATA;
1135 *edit_unit_out = edit_unit;
1137 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1139 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1140 offset_temp += s->edit_unit_byte_count * s->index_duration;
1145 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);
1147 return AVERROR_INVALIDDATA;
1150 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1153 int8_t max_temporal_offset = -128;
1155 /* first compute how many entries we have */
1156 for (i = 0; i < index_table->nb_segments; i++) {
1157 MXFIndexTableSegment *s = index_table->segments[i];
1159 if (!s->nb_index_entries) {
1160 index_table->nb_ptses = 0;
1161 return 0; /* no TemporalOffsets */
1164 index_table->nb_ptses += s->index_duration;
1167 /* paranoid check */
1168 if (index_table->nb_ptses <= 0)
1171 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1172 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1173 av_freep(&index_table->ptses);
1174 return AVERROR(ENOMEM);
1177 /* we may have a few bad TemporalOffsets
1178 * make sure the corresponding PTSes don't have the bogus value 0 */
1179 for (x = 0; x < index_table->nb_ptses; x++)
1180 index_table->ptses[x] = AV_NOPTS_VALUE;
1194 * We want to transform it into this:
1205 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1206 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1207 * The latter makes DTS <= PTS.
1209 for (i = x = 0; i < index_table->nb_segments; i++) {
1210 MXFIndexTableSegment *s = index_table->segments[i];
1211 int index_delta = 1;
1212 int n = s->nb_index_entries;
1214 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1215 index_delta = 2; /* Avid index */
1216 /* ignore the last entry - it's the size of the essence container */
1220 for (j = 0; j < n; j += index_delta, x++) {
1221 int offset = s->temporal_offset_entries[j] / index_delta;
1222 int index = x + offset;
1224 if (x >= index_table->nb_ptses) {
1225 av_log(mxf->fc, AV_LOG_ERROR,
1226 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1227 s->nb_index_entries, s->index_duration);
1231 index_table->fake_index[x].timestamp = x;
1232 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1234 if (index < 0 || index >= index_table->nb_ptses) {
1235 av_log(mxf->fc, AV_LOG_ERROR,
1236 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1241 index_table->ptses[index] = x;
1242 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1246 index_table->first_dts = -max_temporal_offset;
1252 * Sorts and collects index table segments into index tables.
1253 * Also computes PTSes if possible.
1255 static int mxf_compute_index_tables(MXFContext *mxf)
1257 int i, j, k, ret, nb_sorted_segments;
1258 MXFIndexTableSegment **sorted_segments = NULL;
1260 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1261 nb_sorted_segments <= 0) {
1262 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1266 /* sanity check and count unique BodySIDs/IndexSIDs */
1267 for (i = 0; i < nb_sorted_segments; i++) {
1268 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1269 mxf->nb_index_tables++;
1270 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1271 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1272 ret = AVERROR_INVALIDDATA;
1273 goto finish_decoding_index;
1277 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1278 sizeof(*mxf->index_tables));
1279 if (!mxf->index_tables) {
1280 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1281 ret = AVERROR(ENOMEM);
1282 goto finish_decoding_index;
1285 /* distribute sorted segments to index tables */
1286 for (i = j = 0; i < nb_sorted_segments; i++) {
1287 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1292 mxf->index_tables[j].nb_segments++;
1295 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1296 MXFIndexTable *t = &mxf->index_tables[j];
1298 t->segments = av_mallocz_array(t->nb_segments,
1299 sizeof(*t->segments));
1302 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1303 " pointer array\n");
1304 ret = AVERROR(ENOMEM);
1305 goto finish_decoding_index;
1308 if (sorted_segments[i]->index_start_position)
1309 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1310 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1312 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1313 t->index_sid = sorted_segments[i]->index_sid;
1314 t->body_sid = sorted_segments[i]->body_sid;
1316 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1317 goto finish_decoding_index;
1319 /* fix zero IndexDurations */
1320 for (k = 0; k < t->nb_segments; k++) {
1321 if (t->segments[k]->index_duration)
1324 if (t->nb_segments > 1)
1325 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1328 if (mxf->fc->nb_streams <= 0) {
1329 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1333 /* assume the first stream's duration is reasonable
1334 * leave index_duration = 0 on further segments in case we have any (unlikely)
1336 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1342 finish_decoding_index:
1343 av_free(sorted_segments);
1347 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1349 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1350 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1351 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1352 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1355 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1357 char buf[AV_TIMECODE_STR_SIZE];
1358 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1363 static int mxf_parse_structural_metadata(MXFContext *mxf)
1365 MXFPackage *material_package = NULL;
1366 MXFPackage *temp_package = NULL;
1369 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1370 /* TODO: handle multiple material packages (OP3x) */
1371 for (i = 0; i < mxf->packages_count; i++) {
1372 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1373 if (material_package) break;
1375 if (!material_package) {
1376 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1377 return AVERROR_INVALIDDATA;
1380 for (i = 0; i < material_package->tracks_count; i++) {
1381 MXFPackage *source_package = NULL;
1382 MXFTrack *material_track = NULL;
1383 MXFTrack *source_track = NULL;
1384 MXFTrack *temp_track = NULL;
1385 MXFDescriptor *descriptor = NULL;
1386 MXFStructuralComponent *component = NULL;
1387 MXFTimecodeComponent *mxf_tc = NULL;
1388 UID *essence_container_ul = NULL;
1389 const MXFCodecUL *codec_ul = NULL;
1390 const MXFCodecUL *container_ul = NULL;
1391 const MXFCodecUL *pix_fmt_ul = NULL;
1396 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1397 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1401 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1402 mxf_tc = (MXFTimecodeComponent*)component;
1403 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1404 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1405 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1409 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1410 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1414 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1415 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1419 mxf_tc = (MXFTimecodeComponent*)component;
1420 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1421 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1422 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1427 /* TODO: handle multiple source clips */
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], SourceClip);
1433 for (k = 0; k < mxf->packages_count; k++) {
1434 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1437 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1438 source_package = temp_package;
1442 if (!source_package) {
1443 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1446 for (k = 0; k < source_package->tracks_count; k++) {
1447 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1448 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1449 ret = AVERROR_INVALIDDATA;
1452 if (temp_track->track_id == component->source_track_id) {
1453 source_track = temp_track;
1457 if (!source_track) {
1458 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1462 if (!source_track || !component)
1465 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1466 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1467 ret = AVERROR_INVALIDDATA;
1471 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1472 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1473 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1474 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1478 st = avformat_new_stream(mxf->fc, NULL);
1480 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1481 ret = AVERROR(ENOMEM);
1484 st->id = source_track->track_id;
1485 st->priv_data = source_track;
1486 source_track->original_duration = st->duration = component->duration;
1487 if (st->duration == -1)
1488 st->duration = AV_NOPTS_VALUE;
1489 st->start_time = component->start_position;
1490 if (material_track->edit_rate.num <= 0 ||
1491 material_track->edit_rate.den <= 0) {
1492 av_log(mxf->fc, AV_LOG_WARNING,
1493 "Invalid edit rate (%d/%d) found on stream #%d, "
1494 "defaulting to 25/1\n",
1495 material_track->edit_rate.num,
1496 material_track->edit_rate.den, st->index);
1497 material_track->edit_rate = (AVRational){25, 1};
1499 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1501 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only
1502 * the former is accessible via st->priv_data */
1503 source_track->edit_rate = material_track->edit_rate;
1505 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1506 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1507 st->codec->codec_type = codec_ul->id;
1509 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1510 if (source_package->descriptor) {
1511 if (source_package->descriptor->type == MultipleDescriptor) {
1512 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1513 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1515 if (!sub_descriptor) {
1516 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1519 if (sub_descriptor->linked_track_id == source_track->track_id) {
1520 descriptor = sub_descriptor;
1524 } else if (source_package->descriptor->type == Descriptor)
1525 descriptor = source_package->descriptor;
1528 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1531 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1532 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1533 essence_container_ul = &descriptor->essence_container_ul;
1534 /* HACK: replacing the original key with mxf_encrypted_essence_container
1535 * is not allowed according to s429-6, try to find correct information anyway */
1536 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1537 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1538 for (k = 0; k < mxf->metadata_sets_count; k++) {
1539 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1540 if (metadata->type == CryptoContext) {
1541 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1547 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1548 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1549 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1550 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1551 avcodec_get_name(st->codec->codec_id));
1552 for (k = 0; k < 16; k++) {
1553 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1554 descriptor->essence_codec_ul[k]);
1555 if (!(k+1 & 19) || k == 5)
1556 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1558 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1560 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1561 source_track->intra_only = mxf_is_intra_only(descriptor);
1562 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1563 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1564 st->codec->codec_id = container_ul->id;
1565 st->codec->width = descriptor->width;
1566 st->codec->height = descriptor->height; /* Field height, not frame height */
1567 switch (descriptor->frame_layout) {
1568 case SegmentedFrame:
1569 /* This one is a weird layout I don't fully understand. */
1570 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1573 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1576 /* Every other line is stored and needs to be duplicated. */
1577 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1578 break; /* The correct thing to do here is fall through, but by breaking we might be
1579 able to decode some streams at half the vertical resolution, rather than not al all.
1580 It's also for compatibility with the old behavior. */
1583 case SeparateFields:
1584 switch (descriptor->field_dominance) {
1586 st->codec->field_order = AV_FIELD_TT;
1589 st->codec->field_order = AV_FIELD_BB;
1592 avpriv_request_sample(mxf->fc,
1593 "Field dominance %d support",
1594 descriptor->field_dominance);
1597 /* Turn field height into frame height. */
1598 st->codec->height *= 2;
1601 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1603 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1604 st->codec->pix_fmt = descriptor->pix_fmt;
1605 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1606 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1607 &descriptor->essence_codec_ul);
1608 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1609 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1610 /* support files created before RP224v10 by defaulting to UYVY422
1611 if subsampling is 4:2:2 and component depth is 8-bit */
1612 if (descriptor->horiz_subsampling == 2 &&
1613 descriptor->vert_subsampling == 1 &&
1614 descriptor->component_depth == 8) {
1615 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1620 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1621 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1622 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1623 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1624 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))
1625 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1626 st->codec->channels = descriptor->channels;
1627 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1629 if (descriptor->sample_rate.den > 0) {
1630 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1631 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1633 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1634 "found for stream #%d, time base forced to 1/48000\n",
1635 descriptor->sample_rate.num, descriptor->sample_rate.den,
1637 avpriv_set_pts_info(st, 64, 1, 48000);
1640 /* if duration is set, rescale it from EditRate to SampleRate */
1641 if (st->duration != AV_NOPTS_VALUE)
1642 st->duration = av_rescale_q(st->duration,
1643 av_inv_q(material_track->edit_rate),
1646 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1647 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1648 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1649 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1650 else if (descriptor->bits_per_sample == 32)
1651 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1652 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1653 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1654 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1655 else if (descriptor->bits_per_sample == 32)
1656 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1657 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1658 st->need_parsing = AVSTREAM_PARSE_FULL;
1661 if (descriptor->extradata) {
1662 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1663 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1665 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1666 ret = ff_generate_avci_extradata(st);
1670 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1671 /* TODO: decode timestamps */
1672 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1681 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1687 return AVERROR(EINVAL);
1689 buf_size = size + size / 2 + 1;
1690 *str = av_malloc(buf_size);
1692 return AVERROR(ENOMEM);
1694 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1702 static int mxf_uid_to_str(UID uid, char **str)
1706 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1708 return AVERROR(ENOMEM);
1709 for (i = 0; i < sizeof(UID); i++) {
1710 snprintf(p, 2 + 1, "%.2x", uid[i]);
1712 if (i == 3 || i == 5 || i == 7 || i == 9) {
1713 snprintf(p, 1 + 1, "-");
1720 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1722 struct tm time = { 0 };
1723 time.tm_year = (timestamp >> 48) - 1900;
1724 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1725 time.tm_mday = (timestamp >> 32 & 0xFF);
1726 time.tm_hour = (timestamp >> 24 & 0xFF);
1727 time.tm_min = (timestamp >> 16 & 0xFF);
1728 time.tm_sec = (timestamp >> 8 & 0xFF);
1730 /* msvcrt versions of strftime calls the invalid parameter handler
1731 * (aborting the process if one isn't set) if the parameters are out
1733 time.tm_mon = av_clip(time.tm_mon, 0, 11);
1734 time.tm_mday = av_clip(time.tm_mday, 1, 31);
1735 time.tm_hour = av_clip(time.tm_hour, 0, 23);
1736 time.tm_min = av_clip(time.tm_min, 0, 59);
1737 time.tm_sec = av_clip(time.tm_sec, 0, 59);
1739 *str = av_mallocz(32);
1741 return AVERROR(ENOMEM);
1742 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1747 #define SET_STR_METADATA(pb, name, str) do { \
1748 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1750 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1753 #define SET_UID_METADATA(pb, name, var, str) do { \
1754 avio_read(pb, var, 16); \
1755 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1757 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1760 #define SET_TS_METADATA(pb, name, var, str) do { \
1761 var = avio_rb64(pb); \
1762 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1764 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1767 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1769 MXFContext *mxf = arg;
1770 AVFormatContext *s = mxf->fc;
1777 SET_STR_METADATA(pb, "company_name", str);
1780 SET_STR_METADATA(pb, "product_name", str);
1783 SET_STR_METADATA(pb, "product_version", str);
1786 SET_UID_METADATA(pb, "product_uid", uid, str);
1789 SET_TS_METADATA(pb, "modification_date", ts, str);
1792 SET_STR_METADATA(pb, "application_platform", str);
1795 SET_UID_METADATA(pb, "generation_uid", uid, str);
1798 SET_UID_METADATA(pb, "uid", uid, str);
1804 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1805 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1806 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1807 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1808 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1809 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1810 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1811 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1812 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1813 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1814 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1815 { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1816 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1817 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1818 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1819 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1820 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0f,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1821 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1822 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1823 { { 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 */
1824 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1825 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1826 { { 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 */
1827 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1828 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1829 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1830 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1831 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1832 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1833 { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1834 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1837 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1839 AVIOContext *pb = mxf->fc->pb;
1840 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1841 uint64_t klv_end = avio_tell(pb) + klv->length;
1844 return AVERROR(ENOMEM);
1845 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1847 int tag = avio_rb16(pb);
1848 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1849 uint64_t next = avio_tell(pb) + size;
1852 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1853 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1854 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1857 if (tag > 0x7FFF) { /* dynamic tag */
1859 for (i = 0; i < mxf->local_tags_count; i++) {
1860 int local_tag = AV_RB16(mxf->local_tags+i*18);
1861 if (local_tag == tag) {
1862 memcpy(uid, mxf->local_tags+i*18+2, 16);
1863 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1864 PRINT_KEY(mxf->fc, "uid", uid);
1868 if (ctx_size && tag == 0x3C0A)
1869 avio_read(pb, ctx->uid, 16);
1870 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1873 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1874 * it extending past the end of the KLV though (zzuf5.mxf). */
1875 if (avio_tell(pb) > klv_end) {
1879 av_log(mxf->fc, AV_LOG_ERROR,
1880 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1882 return AVERROR_INVALIDDATA;
1883 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1884 avio_seek(pb, next, SEEK_SET);
1886 if (ctx_size) ctx->type = type;
1887 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1891 * Seeks to the previous partition, if possible
1892 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1894 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1896 AVIOContext *pb = mxf->fc->pb;
1898 if (!mxf->current_partition ||
1899 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1900 return 0; /* we've parsed all partitions */
1902 /* seek to previous partition */
1903 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1904 mxf->current_partition = NULL;
1906 av_dlog(mxf->fc, "seeking to previous partition\n");
1912 * Called when essence is encountered
1913 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1915 static int mxf_parse_handle_essence(MXFContext *mxf)
1917 AVIOContext *pb = mxf->fc->pb;
1920 if (mxf->parsing_backward) {
1921 return mxf_seek_to_previous_partition(mxf);
1923 uint64_t offset = mxf->footer_partition ? mxf->footer_partition
1924 : mxf->last_partition;
1927 av_dlog(mxf->fc, "no last partition\n");
1931 av_dlog(mxf->fc, "seeking to last partition\n");
1933 /* remember where we were so we don't end up seeking further back than this */
1934 mxf->last_forward_tell = avio_tell(pb);
1936 if (!pb->seekable) {
1937 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1941 /* seek to last partition and parse backward */
1942 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1943 av_log(mxf->fc, AV_LOG_ERROR,
1944 "failed to seek to last partition @ 0x%" PRIx64
1945 " (%"PRId64") - partial file?\n",
1946 mxf->run_in + offset, ret);
1950 mxf->current_partition = NULL;
1951 mxf->parsing_backward = 1;
1958 * Called when the next partition or EOF is encountered
1959 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1961 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1963 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1967 * Figures out the proper offset and length of the essence container in each partition
1969 static void mxf_compute_essence_containers(MXFContext *mxf)
1973 /* everything is already correct */
1974 if (mxf->op == OPAtom)
1977 for (x = 0; x < mxf->partitions_count; x++) {
1978 MXFPartition *p = &mxf->partitions[x];
1981 continue; /* BodySID == 0 -> no essence */
1983 if (x >= mxf->partitions_count - 1)
1984 break; /* last partition - can't compute length (and we don't need to) */
1986 /* essence container spans to the next partition */
1987 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1989 if (p->essence_length < 0) {
1990 /* next ThisPartition < essence_offset */
1991 p->essence_length = 0;
1992 av_log(mxf->fc, AV_LOG_ERROR,
1993 "partition %i: bad ThisPartition = %"PRIX64"\n",
1994 x+1, mxf->partitions[x+1].this_partition);
1999 static int64_t round_to_kag(int64_t position, int kag_size)
2001 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
2002 /* NOTE: kag_size may be any integer between 1 - 2^10 */
2003 int64_t ret = (position / kag_size) * kag_size;
2004 return ret == position ? ret : ret + kag_size;
2007 static int is_pcm(enum AVCodecID codec_id)
2009 /* we only care about "normal" PCM codecs until we get samples */
2010 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
2014 * Deal with the case where for some audio atoms EditUnitByteCount is
2015 * very small (2, 4..). In those cases we should read more than one
2016 * sample per call to mxf_read_packet().
2018 static void mxf_handle_small_eubc(AVFormatContext *s)
2020 MXFContext *mxf = s->priv_data;
2022 /* assuming non-OPAtom == frame wrapped
2023 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
2024 if (mxf->op != OPAtom)
2027 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
2028 if (s->nb_streams != 1 ||
2029 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
2030 !is_pcm(s->streams[0]->codec->codec_id) ||
2031 mxf->nb_index_tables != 1 ||
2032 mxf->index_tables[0].nb_segments != 1 ||
2033 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2036 /* arbitrarily default to 48 kHz PAL audio frame size */
2037 /* TODO: We could compute this from the ratio between the audio
2038 * and video edit rates for 48 kHz NTSC we could use the
2039 * 1802-1802-1802-1802-1801 pattern. */
2040 mxf->edit_units_per_packet = 1920;
2043 static void mxf_read_random_index_pack(AVFormatContext *s)
2045 MXFContext *mxf = s->priv_data;
2050 if (!s->pb->seekable)
2053 file_size = avio_size(s->pb);
2054 avio_seek(s->pb, file_size - 4, SEEK_SET);
2055 length = avio_rb32(s->pb);
2056 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2058 avio_seek(s->pb, file_size - length, SEEK_SET);
2059 if (klv_read_packet(&klv, s->pb) < 0 ||
2060 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2061 klv.length != length - 20)
2064 avio_skip(s->pb, klv.length - 12);
2065 mxf->last_partition = avio_rb64(s->pb);
2068 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2071 static int mxf_read_header(AVFormatContext *s)
2073 MXFContext *mxf = s->priv_data;
2075 int64_t essence_offset = 0;
2076 int64_t last_pos = -1;
2077 uint64_t last_pos_index = 1;
2080 mxf->last_forward_tell = INT64_MAX;
2081 mxf->edit_units_per_packet = 1;
2083 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2084 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2085 return AVERROR_INVALIDDATA;
2087 avio_seek(s->pb, -14, SEEK_CUR);
2089 mxf->run_in = avio_tell(s->pb);
2091 mxf_read_random_index_pack(s);
2093 while (!url_feof(s->pb)) {
2094 const MXFMetadataReadTableEntry *metadata;
2095 if (avio_tell(s->pb) == last_pos) {
2096 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2097 return AVERROR_INVALIDDATA;
2099 if ((1ULL<<61) % last_pos_index++ == 0)
2100 last_pos = avio_tell(s->pb);
2101 if (klv_read_packet(&klv, s->pb) < 0) {
2102 /* EOF - seek to previous partition or stop */
2103 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2109 PRINT_KEY(s, "read header", klv.key);
2110 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2111 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2112 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2113 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2114 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2116 if (!mxf->current_partition) {
2117 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2118 return AVERROR_INVALIDDATA;
2121 if (!mxf->current_partition->essence_offset) {
2122 /* for OP1a we compute essence_offset
2123 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2124 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2125 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2127 int64_t op1a_essence_offset =
2128 round_to_kag(mxf->current_partition->this_partition +
2129 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2130 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2131 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2133 if (mxf->op == OPAtom) {
2134 /* point essence_offset to the actual data
2135 * OPAtom has all the essence in one big KLV
2137 mxf->current_partition->essence_offset = avio_tell(s->pb);
2138 mxf->current_partition->essence_length = klv.length;
2140 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2141 mxf->current_partition->essence_offset = op1a_essence_offset;
2145 if (!essence_offset)
2146 essence_offset = klv.offset;
2148 /* seek to footer, previous partition or stop */
2149 if (mxf_parse_handle_essence(mxf) <= 0)
2152 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2153 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2154 /* next partition pack - keep going, seek to previous partition or stop */
2155 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2157 else if (mxf->parsing_backward)
2159 /* we're still parsing forward. proceed to parsing this partition pack */
2162 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2163 if (IS_KLV_KEY(klv.key, metadata->key)) {
2165 if (klv.key[5] == 0x53) {
2166 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2168 uint64_t next = avio_tell(s->pb) + klv.length;
2169 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2171 /* only seek forward, else this can loop for a long time */
2172 if (avio_tell(s->pb) > next) {
2173 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2175 return AVERROR_INVALIDDATA;
2178 avio_seek(s->pb, next, SEEK_SET);
2181 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2187 if (!metadata->read)
2188 avio_skip(s->pb, klv.length);
2190 /* FIXME avoid seek */
2191 if (!essence_offset) {
2192 av_log(s, AV_LOG_ERROR, "no essence\n");
2193 return AVERROR_INVALIDDATA;
2195 avio_seek(s->pb, essence_offset, SEEK_SET);
2197 mxf_compute_essence_containers(mxf);
2199 /* we need to do this before computing the index tables
2200 * to be able to fill in zero IndexDurations with st->duration */
2201 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2204 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2207 if (mxf->nb_index_tables > 1) {
2208 /* TODO: look up which IndexSID to use via EssenceContainerData */
2209 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2210 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2211 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2212 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2213 ret = AVERROR_INVALIDDATA;
2217 mxf_handle_small_eubc(s);
2227 * Sets mxf->current_edit_unit based on what offset we're currently at.
2228 * @return next_ofs if OK, <0 on error
2230 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2232 int64_t last_ofs = -1, next_ofs = -1;
2233 MXFIndexTable *t = &mxf->index_tables[0];
2235 /* this is called from the OP1a demuxing logic, which means there
2236 * may be no index tables */
2237 if (mxf->nb_index_tables <= 0)
2240 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2241 while (mxf->current_edit_unit >= 0) {
2242 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2245 if (next_ofs <= last_ofs) {
2246 /* large next_ofs didn't change or current_edit_unit wrapped
2247 * around this fixes the infinite loop on zzuf3.mxf */
2248 av_log(mxf->fc, AV_LOG_ERROR,
2249 "next_ofs didn't change. not deriving packet timestamps\n");
2253 if (next_ofs > current_offset)
2256 last_ofs = next_ofs;
2257 mxf->current_edit_unit++;
2260 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2261 if (mxf->current_edit_unit < 0)
2267 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index,
2268 uint64_t *sample_count)
2270 int i, total = 0, size = 0;
2271 AVStream *st = mxf->fc->streams[stream_index];
2272 MXFTrack *track = st->priv_data;
2273 AVRational time_base = av_inv_q(track->edit_rate);
2274 AVRational sample_rate = av_inv_q(st->time_base);
2275 const MXFSamplesPerFrame *spf = NULL;
2277 if ((sample_rate.num / sample_rate.den) == 48000)
2278 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2280 int remainder = (sample_rate.num * time_base.num) %
2281 (time_base.den * sample_rate.den);
2282 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2283 av_mul_q(sample_rate, time_base)));
2285 av_log(mxf->fc, AV_LOG_WARNING,
2286 "seeking detected on stream #%d with time base (%d/%d) and "
2287 "sample rate (%d/%d), audio pts won't be accurate.\n",
2288 stream_index, time_base.num, time_base.den,
2289 sample_rate.num, sample_rate.den);
2293 while (spf->samples_per_frame[size]) {
2294 total += spf->samples_per_frame[size];
2300 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2301 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2302 *sample_count += spf->samples_per_frame[i];
2308 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec,
2311 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2312 int64_t bits_per_sample = av_get_bits_per_sample(codec->codec_id);
2314 pkt->pts = track->sample_count;
2316 if ( codec->channels <= 0
2317 || bits_per_sample <= 0
2318 || codec->channels * (int64_t)bits_per_sample < 8)
2319 return AVERROR(EINVAL);
2320 track->sample_count += pkt->size / (codec->channels * (int64_t)bits_per_sample / 8);
2324 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2327 MXFContext *mxf = s->priv_data;
2330 while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
2331 PRINT_KEY(s, "read packet", klv.key);
2332 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2333 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2334 ret = mxf_decrypt_triplet(s, pkt, &klv);
2336 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2341 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2342 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2343 int index = mxf_get_stream_index(s, &klv);
2344 int64_t next_ofs, next_klv;
2347 AVCodecContext *codec;
2350 av_log(s, AV_LOG_ERROR,
2351 "error getting stream index %"PRIu32"\n",
2352 AV_RB32(klv.key + 12));
2356 st = s->streams[index];
2357 track = st->priv_data;
2359 if (s->streams[index]->discard == AVDISCARD_ALL)
2362 next_klv = avio_tell(s->pb) + klv.length;
2363 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2365 if (next_ofs >= 0 && next_klv > next_ofs) {
2366 /* if this check is hit then it's possible OPAtom was treated as OP1a
2367 * truncate the packet since it's probably very large (>2 GiB is common) */
2368 avpriv_request_sample(s,
2369 "OPAtom misinterpreted as OP1a?"
2370 "KLV for edit unit %i extending into "
2372 mxf->current_edit_unit);
2373 klv.length = next_ofs - avio_tell(s->pb);
2376 /* check for 8 channels AES3 element */
2377 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2378 ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index],
2381 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2385 ret = av_get_packet(s->pb, pkt, klv.length);
2389 pkt->stream_index = index;
2390 pkt->pos = klv.offset;
2392 codec = s->streams[index]->codec;
2394 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2395 /* mxf->current_edit_unit good - see if we have an
2396 * index table to derive timestamps from */
2397 MXFIndexTable *t = &mxf->index_tables[0];
2399 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2400 pkt->dts = mxf->current_edit_unit + t->first_dts;
2401 pkt->pts = t->ptses[mxf->current_edit_unit];
2402 } else if (track->intra_only) {
2403 /* intra-only -> PTS = EditUnit.
2404 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2405 pkt->pts = mxf->current_edit_unit;
2407 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2408 ret = mxf_set_audio_pts(mxf, codec, pkt);
2413 /* seek for truncated packets */
2414 avio_seek(s->pb, next_klv, SEEK_SET);
2419 avio_skip(s->pb, klv.length);
2421 return url_feof(s->pb) ? AVERROR_EOF : ret;
2424 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2426 MXFContext *mxf = s->priv_data;
2428 int64_t ret64, pos, next_pos;
2433 if (mxf->op != OPAtom)
2434 return mxf_read_packet_old(s, pkt);
2436 /* OPAtom - clip wrapped demuxing */
2437 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2439 t = &mxf->index_tables[0];
2441 if (mxf->current_edit_unit >= st->duration)
2444 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2446 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2449 /* compute size by finding the next edit unit or the end of the essence container
2450 * not pretty, but it works */
2451 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2452 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2453 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2454 return AVERROR_INVALIDDATA;
2457 if ((size = next_pos - pos) <= 0) {
2458 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2459 return AVERROR_INVALIDDATA;
2462 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2465 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2468 pkt->stream_index = 0;
2470 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2471 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2472 pkt->dts = mxf->current_edit_unit + t->first_dts;
2473 pkt->pts = t->ptses[mxf->current_edit_unit];
2474 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2475 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2480 mxf->current_edit_unit += edit_units;
2485 static int mxf_read_close(AVFormatContext *s)
2487 MXFContext *mxf = s->priv_data;
2488 MXFIndexTableSegment *seg;
2491 av_freep(&mxf->packages_refs);
2493 for (i = 0; i < s->nb_streams; i++)
2494 s->streams[i]->priv_data = NULL;
2496 for (i = 0; i < mxf->metadata_sets_count; i++) {
2497 switch (mxf->metadata_sets[i]->type) {
2499 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2501 case MultipleDescriptor:
2502 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2505 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2508 case MaterialPackage:
2509 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2511 case IndexTableSegment:
2512 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2513 av_freep(&seg->temporal_offset_entries);
2514 av_freep(&seg->flag_entries);
2515 av_freep(&seg->stream_offset_entries);
2520 av_freep(&mxf->metadata_sets[i]);
2522 av_freep(&mxf->partitions);
2523 av_freep(&mxf->metadata_sets);
2524 av_freep(&mxf->aesc);
2525 av_freep(&mxf->local_tags);
2527 if (mxf->index_tables) {
2528 for (i = 0; i < mxf->nb_index_tables; i++) {
2529 av_freep(&mxf->index_tables[i].segments);
2530 av_freep(&mxf->index_tables[i].ptses);
2531 av_freep(&mxf->index_tables[i].fake_index);
2534 av_freep(&mxf->index_tables);
2539 static int mxf_probe(AVProbeData *p) {
2540 const uint8_t *bufp = p->buf;
2541 const uint8_t *end = p->buf + p->buf_size;
2543 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2546 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2547 end -= sizeof(mxf_header_partition_pack_key);
2549 for (; bufp < end;) {
2550 if (!((bufp[13] - 1) & 0xF2)){
2551 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2552 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2553 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2554 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2555 return AVPROBE_SCORE_MAX;
2564 /* rudimentary byte seek */
2565 /* XXX: use MXF Index */
2566 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2568 AVStream *st = s->streams[stream_index];
2570 MXFContext* mxf = s->priv_data;
2574 MXFTrack *source_track = st->priv_data;
2576 /* if audio then truncate sample_time to EditRate */
2577 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2578 sample_time = av_rescale_q(sample_time, st->time_base,
2579 av_inv_q(source_track->edit_rate));
2581 if (mxf->nb_index_tables <= 0) {
2583 return AVERROR_INVALIDDATA;
2584 if (sample_time < 0)
2586 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2588 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2592 ff_update_cur_dts(s, st, sample_time);
2593 mxf->current_edit_unit = sample_time;
2595 t = &mxf->index_tables[0];
2597 /* clamp above zero, else ff_index_search_timestamp() returns negative
2598 * this also means we allow seeking before the start */
2599 sample_time = FFMAX(sample_time, 0);
2601 if (t->fake_index) {
2602 /* behave as if we have a proper index */
2603 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2606 /* no IndexEntryArray (one or more CBR segments)
2607 * make sure we don't seek past the end */
2608 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2611 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2614 ff_update_cur_dts(s, st, sample_time);
2615 mxf->current_edit_unit = sample_time;
2616 avio_seek(s->pb, seekpos, SEEK_SET);
2619 // Update all tracks sample count
2620 for (i = 0; i < s->nb_streams; i++) {
2621 AVStream *cur_st = s->streams[i];
2622 MXFTrack *cur_track = cur_st->priv_data;
2623 uint64_t current_sample_count = 0;
2624 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2625 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2629 cur_track->sample_count = current_sample_count;
2635 AVInputFormat ff_mxf_demuxer = {
2637 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2638 .priv_data_size = sizeof(MXFContext),
2639 .read_probe = mxf_probe,
2640 .read_header = mxf_read_header,
2641 .read_packet = mxf_read_packet,
2642 .read_close = mxf_read_close,
2643 .read_seek = mxf_read_seek,