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; ///< duration before multiplying st->duration by SampleRate/EditRate
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 /* some files don'thave FooterPartition set in every partition */
499 if (footer_partition) {
500 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
501 av_log(mxf->fc, AV_LOG_ERROR,
502 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
503 mxf->footer_partition, footer_partition);
505 mxf->footer_partition = footer_partition;
510 "PartitionPack: ThisPartition = 0x%"PRIX64
511 ", PreviousPartition = 0x%"PRIX64", "
512 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
513 partition->this_partition,
514 partition->previous_partition, footer_partition,
515 partition->index_sid, partition->body_sid);
517 /* sanity check PreviousPartition if set */
518 if (partition->previous_partition &&
519 mxf->run_in + partition->previous_partition >= klv_offset) {
520 av_log(mxf->fc, AV_LOG_ERROR,
521 "PreviousPartition points to this partition or forward\n");
522 return AVERROR_INVALIDDATA;
525 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
526 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
527 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
528 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
529 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
530 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
531 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
532 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
533 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
534 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
535 else if (op[12] == 0x10) {
536 /* SMPTE 390m: "There shall be exactly one essence container"
537 * The following block deals with files that violate this, namely:
538 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
539 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
540 if (nb_essence_containers != 1) {
541 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
545 av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
546 nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
552 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
556 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
557 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
559 if (mxf->op == OPSONYOpt)
560 partition->kag_size = 512;
562 partition->kag_size = 1;
564 av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
570 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
572 MXFMetadataSet **tmp;
574 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
576 return AVERROR(ENOMEM);
577 mxf->metadata_sets = tmp;
578 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
579 mxf->metadata_sets_count++;
583 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
585 MXFCryptoContext *cryptocontext = arg;
587 return AVERROR_INVALIDDATA;
588 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
589 avio_read(pb, cryptocontext->source_container_ul, 16);
593 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
595 MXFContext *mxf = arg;
598 mxf->packages_count = avio_rb32(pb);
599 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
600 if (!mxf->packages_refs)
601 return AVERROR(ENOMEM);
602 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
603 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
609 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
611 MXFStructuralComponent *source_clip = arg;
614 source_clip->duration = avio_rb64(pb);
617 source_clip->start_position = avio_rb64(pb);
620 /* UMID, only get last 16 bytes */
622 avio_read(pb, source_clip->source_package_uid, 16);
625 source_clip->source_track_id = avio_rb32(pb);
631 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
633 MXFPackage *package = arg;
636 package->tracks_count = avio_rb32(pb);
637 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
638 if (!package->tracks_refs)
639 return AVERROR(ENOMEM);
640 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
641 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
647 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
649 MXFTimecodeComponent *mxf_timecode = arg;
652 mxf_timecode->start_frame = avio_rb64(pb);
655 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
658 mxf_timecode->drop_frame = avio_r8(pb);
664 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
666 MXFTrack *track = arg;
669 track->track_id = avio_rb32(pb);
672 avio_read(pb, track->track_number, 4);
675 track->edit_rate.num = avio_rb32(pb);
676 track->edit_rate.den = avio_rb32(pb);
679 avio_read(pb, track->sequence_ref, 16);
685 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
687 MXFSequence *sequence = arg;
690 sequence->duration = avio_rb64(pb);
693 avio_read(pb, sequence->data_definition_ul, 16);
696 sequence->structural_components_count = avio_rb32(pb);
697 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
698 if (!sequence->structural_components_refs)
699 return AVERROR(ENOMEM);
700 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
701 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
707 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
709 MXFPackage *package = arg;
712 package->tracks_count = avio_rb32(pb);
713 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
714 if (!package->tracks_refs)
715 return AVERROR(ENOMEM);
716 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
717 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
720 /* UMID, only get last 16 bytes */
722 avio_read(pb, package->package_uid, 16);
725 avio_read(pb, package->descriptor_ref, 16);
731 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
735 segment->nb_index_entries = avio_rb32(pb);
737 length = avio_rb32(pb);
739 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
740 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
741 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
742 return AVERROR(ENOMEM);
744 for (i = 0; i < segment->nb_index_entries; i++) {
745 segment->temporal_offset_entries[i] = avio_r8(pb);
746 avio_r8(pb); /* KeyFrameOffset */
747 segment->flag_entries[i] = avio_r8(pb);
748 segment->stream_offset_entries[i] = avio_rb64(pb);
749 avio_skip(pb, length - 11);
754 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
756 MXFIndexTableSegment *segment = arg;
759 segment->edit_unit_byte_count = avio_rb32(pb);
760 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
763 segment->index_sid = avio_rb32(pb);
764 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
767 segment->body_sid = avio_rb32(pb);
768 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
771 av_dlog(NULL, "IndexEntryArray found\n");
772 return mxf_read_index_entry_array(pb, segment);
774 segment->index_edit_rate.num = avio_rb32(pb);
775 segment->index_edit_rate.den = avio_rb32(pb);
776 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
777 segment->index_edit_rate.den);
780 segment->index_start_position = avio_rb64(pb);
781 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
784 segment->index_duration = avio_rb64(pb);
785 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
791 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
793 int code, value, ofs = 0;
794 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
799 av_dlog(NULL, "pixel layout: code %#x\n", code);
802 layout[ofs++] = code;
803 layout[ofs++] = value;
805 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
806 } while (code != 0); /* SMPTE 377M E.2.46 */
808 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
811 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
813 MXFDescriptor *descriptor = arg;
814 descriptor->pix_fmt = AV_PIX_FMT_NONE;
817 descriptor->sub_descriptors_count = avio_rb32(pb);
818 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
819 if (!descriptor->sub_descriptors_refs)
820 return AVERROR(ENOMEM);
821 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
822 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
825 avio_read(pb, descriptor->essence_container_ul, 16);
828 descriptor->linked_track_id = avio_rb32(pb);
830 case 0x3201: /* PictureEssenceCoding */
831 avio_read(pb, descriptor->essence_codec_ul, 16);
834 descriptor->width = avio_rb32(pb);
837 descriptor->height = avio_rb32(pb);
840 descriptor->frame_layout = avio_r8(pb);
843 descriptor->aspect_ratio.num = avio_rb32(pb);
844 descriptor->aspect_ratio.den = avio_rb32(pb);
847 descriptor->field_dominance = avio_r8(pb);
850 descriptor->component_depth = avio_rb32(pb);
853 descriptor->horiz_subsampling = avio_rb32(pb);
856 descriptor->vert_subsampling = avio_rb32(pb);
859 descriptor->sample_rate.num = avio_rb32(pb);
860 descriptor->sample_rate.den = avio_rb32(pb);
862 case 0x3D06: /* SoundEssenceCompression */
863 avio_read(pb, descriptor->essence_codec_ul, 16);
866 descriptor->channels = avio_rb32(pb);
869 descriptor->bits_per_sample = avio_rb32(pb);
872 mxf_read_pixel_layout(pb, descriptor);
875 /* Private uid used by SONY C0023S01.mxf */
876 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
877 if (descriptor->extradata)
878 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
879 av_free(descriptor->extradata);
880 descriptor->extradata_size = 0;
881 descriptor->extradata = av_malloc(size);
882 if (!descriptor->extradata)
883 return AVERROR(ENOMEM);
884 descriptor->extradata_size = size;
885 avio_read(pb, descriptor->extradata, size);
893 * Match an uid independently of the version byte and up to len common bytes
896 static int mxf_match_uid(const UID key, const UID uid, int len)
899 for (i = 0; i < len; i++) {
900 if (i != 7 && key[i] != uid[i])
906 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
908 while (uls->uid[0]) {
909 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
916 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
922 for (i = 0; i < mxf->metadata_sets_count; i++) {
923 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
924 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
925 return mxf->metadata_sets[i];
931 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
932 // video essence container uls
933 { { 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 */
934 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
935 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
936 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
939 /* EC ULs for intra-only formats */
940 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
941 { { 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 */
942 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
945 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
946 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
947 { { 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 */
948 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
949 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
952 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
953 // sound essence container uls
954 { { 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 */
955 { { 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 */
956 { { 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 */
957 { { 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 */
958 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
961 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
963 int i, j, nb_segments = 0;
964 MXFIndexTableSegment **unsorted_segments;
965 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
967 /* count number of segments, allocate arrays and copy unsorted segments */
968 for (i = 0; i < mxf->metadata_sets_count; i++)
969 if (mxf->metadata_sets[i]->type == IndexTableSegment)
973 return AVERROR_INVALIDDATA;
975 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
976 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
977 av_freep(sorted_segments);
978 av_free(unsorted_segments);
979 return AVERROR(ENOMEM);
982 for (i = j = 0; i < mxf->metadata_sets_count; i++)
983 if (mxf->metadata_sets[i]->type == IndexTableSegment)
984 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
986 *nb_sorted_segments = 0;
988 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
989 for (i = 0; i < nb_segments; i++) {
990 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
991 uint64_t best_index_duration = 0;
993 for (j = 0; j < nb_segments; j++) {
994 MXFIndexTableSegment *s = unsorted_segments[j];
996 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
997 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
998 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
1000 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
1001 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1002 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1004 best_body_sid = s->body_sid;
1005 best_index_sid = s->index_sid;
1006 best_index_start = s->index_start_position;
1007 best_index_duration = s->index_duration;
1011 /* no suitable entry found -> we're done */
1015 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1016 last_body_sid = best_body_sid;
1017 last_index_sid = best_index_sid;
1018 last_index_start = best_index_start;
1021 av_free(unsorted_segments);
1027 * Computes the absolute file offset of the given essence container offset
1029 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1032 int64_t offset_in = offset; /* for logging */
1034 for (x = 0; x < mxf->partitions_count; x++) {
1035 MXFPartition *p = &mxf->partitions[x];
1037 if (p->body_sid != body_sid)
1040 if (offset < p->essence_length || !p->essence_length) {
1041 *offset_out = p->essence_offset + offset;
1045 offset -= p->essence_length;
1048 av_log(mxf->fc, AV_LOG_ERROR,
1049 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1050 offset_in, body_sid);
1052 return AVERROR_INVALIDDATA;
1056 * Returns the end position of the essence container with given BodySID, or zero if unknown
1058 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1063 for (x = 0; x < mxf->partitions_count; x++) {
1064 MXFPartition *p = &mxf->partitions[x];
1066 if (p->body_sid != body_sid)
1069 if (!p->essence_length)
1072 ret = p->essence_offset + p->essence_length;
1078 /* EditUnit -> absolute offset */
1079 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)
1082 int64_t offset_temp = 0;
1084 for (i = 0; i < index_table->nb_segments; i++) {
1085 MXFIndexTableSegment *s = index_table->segments[i];
1087 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1089 if (edit_unit < s->index_start_position + s->index_duration) {
1090 int64_t index = edit_unit - s->index_start_position;
1092 if (s->edit_unit_byte_count)
1093 offset_temp += s->edit_unit_byte_count * index;
1094 else if (s->nb_index_entries) {
1095 if (s->nb_index_entries == 2 * s->index_duration + 1)
1096 index *= 2; /* Avid index */
1098 if (index < 0 || index >= s->nb_index_entries) {
1099 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1100 index_table->index_sid, s->index_start_position);
1101 return AVERROR_INVALIDDATA;
1104 offset_temp = s->stream_offset_entries[index];
1106 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1107 index_table->index_sid, s->index_start_position);
1108 return AVERROR_INVALIDDATA;
1112 *edit_unit_out = edit_unit;
1114 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1116 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1117 offset_temp += s->edit_unit_byte_count * s->index_duration;
1122 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);
1124 return AVERROR_INVALIDDATA;
1127 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1130 int8_t max_temporal_offset = -128;
1132 /* first compute how many entries we have */
1133 for (i = 0; i < index_table->nb_segments; i++) {
1134 MXFIndexTableSegment *s = index_table->segments[i];
1136 if (!s->nb_index_entries) {
1137 index_table->nb_ptses = 0;
1138 return 0; /* no TemporalOffsets */
1141 index_table->nb_ptses += s->index_duration;
1144 /* paranoid check */
1145 if (index_table->nb_ptses <= 0)
1148 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1149 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1150 av_freep(&index_table->ptses);
1151 return AVERROR(ENOMEM);
1154 /* we may have a few bad TemporalOffsets
1155 * make sure the corresponding PTSes don't have the bogus value 0 */
1156 for (x = 0; x < index_table->nb_ptses; x++)
1157 index_table->ptses[x] = AV_NOPTS_VALUE;
1171 * We want to transform it into this:
1182 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1183 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1184 * The latter makes DTS <= PTS.
1186 for (i = x = 0; i < index_table->nb_segments; i++) {
1187 MXFIndexTableSegment *s = index_table->segments[i];
1188 int index_delta = 1;
1189 int n = s->nb_index_entries;
1191 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1192 index_delta = 2; /* Avid index */
1193 /* ignore the last entry - it's the size of the essence container */
1197 for (j = 0; j < n; j += index_delta, x++) {
1198 int offset = s->temporal_offset_entries[j] / index_delta;
1199 int index = x + offset;
1201 if (x >= index_table->nb_ptses) {
1202 av_log(mxf->fc, AV_LOG_ERROR,
1203 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1204 s->nb_index_entries, s->index_duration);
1208 index_table->fake_index[x].timestamp = x;
1209 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1211 if (index < 0 || index >= index_table->nb_ptses) {
1212 av_log(mxf->fc, AV_LOG_ERROR,
1213 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1218 index_table->ptses[index] = x;
1219 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1223 index_table->first_dts = -max_temporal_offset;
1229 * Sorts and collects index table segments into index tables.
1230 * Also computes PTSes if possible.
1232 static int mxf_compute_index_tables(MXFContext *mxf)
1234 int i, j, k, ret, nb_sorted_segments;
1235 MXFIndexTableSegment **sorted_segments = NULL;
1237 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1238 nb_sorted_segments <= 0) {
1239 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1243 /* sanity check and count unique BodySIDs/IndexSIDs */
1244 for (i = 0; i < nb_sorted_segments; i++) {
1245 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1246 mxf->nb_index_tables++;
1247 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1248 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1249 ret = AVERROR_INVALIDDATA;
1250 goto finish_decoding_index;
1254 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1255 sizeof(*mxf->index_tables));
1256 if (!mxf->index_tables) {
1257 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1258 ret = AVERROR(ENOMEM);
1259 goto finish_decoding_index;
1262 /* distribute sorted segments to index tables */
1263 for (i = j = 0; i < nb_sorted_segments; i++) {
1264 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1269 mxf->index_tables[j].nb_segments++;
1272 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1273 MXFIndexTable *t = &mxf->index_tables[j];
1275 t->segments = av_mallocz_array(t->nb_segments,
1276 sizeof(*t->segments));
1279 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1280 " pointer array\n");
1281 ret = AVERROR(ENOMEM);
1282 goto finish_decoding_index;
1285 if (sorted_segments[i]->index_start_position)
1286 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1287 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1289 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1290 t->index_sid = sorted_segments[i]->index_sid;
1291 t->body_sid = sorted_segments[i]->body_sid;
1293 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1294 goto finish_decoding_index;
1296 /* fix zero IndexDurations */
1297 for (k = 0; k < t->nb_segments; k++) {
1298 if (t->segments[k]->index_duration)
1301 if (t->nb_segments > 1)
1302 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1305 if (mxf->fc->nb_streams <= 0) {
1306 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1310 /* assume the first stream's duration is reasonable
1311 * leave index_duration = 0 on further segments in case we have any (unlikely)
1313 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1319 finish_decoding_index:
1320 av_free(sorted_segments);
1324 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1326 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1327 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1328 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1329 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1332 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1334 char buf[AV_TIMECODE_STR_SIZE];
1335 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1340 static int mxf_parse_structural_metadata(MXFContext *mxf)
1342 MXFPackage *material_package = NULL;
1343 MXFPackage *temp_package = NULL;
1346 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1347 /* TODO: handle multiple material packages (OP3x) */
1348 for (i = 0; i < mxf->packages_count; i++) {
1349 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1350 if (material_package) break;
1352 if (!material_package) {
1353 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1354 return AVERROR_INVALIDDATA;
1357 for (i = 0; i < material_package->tracks_count; i++) {
1358 MXFPackage *source_package = NULL;
1359 MXFTrack *material_track = NULL;
1360 MXFTrack *source_track = NULL;
1361 MXFTrack *temp_track = NULL;
1362 MXFDescriptor *descriptor = NULL;
1363 MXFStructuralComponent *component = NULL;
1364 MXFTimecodeComponent *mxf_tc = NULL;
1365 UID *essence_container_ul = NULL;
1366 const MXFCodecUL *codec_ul = NULL;
1367 const MXFCodecUL *container_ul = NULL;
1368 const MXFCodecUL *pix_fmt_ul = NULL;
1373 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1374 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1378 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1379 mxf_tc = (MXFTimecodeComponent*)component;
1380 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1381 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1382 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1386 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1387 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1391 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1392 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1396 mxf_tc = (MXFTimecodeComponent*)component;
1397 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1398 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1399 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1404 /* TODO: handle multiple source clips */
1405 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1406 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1410 for (k = 0; k < mxf->packages_count; k++) {
1411 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1414 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1415 source_package = temp_package;
1419 if (!source_package) {
1420 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1423 for (k = 0; k < source_package->tracks_count; k++) {
1424 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1425 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1426 ret = AVERROR_INVALIDDATA;
1429 if (temp_track->track_id == component->source_track_id) {
1430 source_track = temp_track;
1434 if (!source_track) {
1435 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1439 if (!source_track || !component)
1442 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1443 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1444 ret = AVERROR_INVALIDDATA;
1448 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1449 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1450 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1451 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1455 st = avformat_new_stream(mxf->fc, NULL);
1457 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1458 ret = AVERROR(ENOMEM);
1461 st->id = source_track->track_id;
1462 st->priv_data = source_track;
1463 source_track->original_duration = st->duration = component->duration;
1464 if (st->duration == -1)
1465 st->duration = AV_NOPTS_VALUE;
1466 st->start_time = component->start_position;
1467 if (material_track->edit_rate.num <= 0 ||
1468 material_track->edit_rate.den <= 0) {
1469 av_log(mxf->fc, AV_LOG_WARNING,
1470 "Invalid edit rate (%d/%d) found on stream #%d, "
1471 "defaulting to 25/1\n",
1472 material_track->edit_rate.num,
1473 material_track->edit_rate.den, st->index);
1474 material_track->edit_rate = (AVRational){25, 1};
1476 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1478 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1479 source_track->edit_rate = material_track->edit_rate;
1481 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1482 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1483 st->codec->codec_type = codec_ul->id;
1485 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1486 if (source_package->descriptor) {
1487 if (source_package->descriptor->type == MultipleDescriptor) {
1488 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1489 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1491 if (!sub_descriptor) {
1492 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1495 if (sub_descriptor->linked_track_id == source_track->track_id) {
1496 descriptor = sub_descriptor;
1500 } else if (source_package->descriptor->type == Descriptor)
1501 descriptor = source_package->descriptor;
1504 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1507 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1508 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1509 essence_container_ul = &descriptor->essence_container_ul;
1510 /* HACK: replacing the original key with mxf_encrypted_essence_container
1511 * is not allowed according to s429-6, try to find correct information anyway */
1512 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1513 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1514 for (k = 0; k < mxf->metadata_sets_count; k++) {
1515 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1516 if (metadata->type == CryptoContext) {
1517 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1523 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1524 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1525 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1526 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1527 avcodec_get_name(st->codec->codec_id));
1528 for (k = 0; k < 16; k++) {
1529 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1530 descriptor->essence_codec_ul[k]);
1531 if (!(k+1 & 19) || k == 5)
1532 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1534 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1536 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1537 source_track->intra_only = mxf_is_intra_only(descriptor);
1538 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1539 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1540 st->codec->codec_id = container_ul->id;
1541 st->codec->width = descriptor->width;
1542 st->codec->height = descriptor->height; /* Field height, not frame height */
1543 switch (descriptor->frame_layout) {
1544 case SegmentedFrame:
1545 /* This one is a weird layout I don't fully understand. */
1546 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1549 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1552 /* Every other line is stored and needs to be duplicated. */
1553 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1554 break; /* The correct thing to do here is fall through, but by breaking we might be
1555 able to decode some streams at half the vertical resolution, rather than not al all.
1556 It's also for compatibility with the old behavior. */
1559 case SeparateFields:
1560 switch (descriptor->field_dominance) {
1562 st->codec->field_order = AV_FIELD_TT;
1565 st->codec->field_order = AV_FIELD_BB;
1568 avpriv_request_sample(mxf->fc,
1569 "Field dominance %d support",
1570 descriptor->field_dominance);
1573 /* Turn field height into frame height. */
1574 st->codec->height *= 2;
1577 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1579 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1580 st->codec->pix_fmt = descriptor->pix_fmt;
1581 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1582 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1583 &descriptor->essence_codec_ul);
1584 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1585 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1586 /* support files created before RP224v10 by defaulting to UYVY422
1587 if subsampling is 4:2:2 and component depth is 8-bit */
1588 if (descriptor->horiz_subsampling == 2 &&
1589 descriptor->vert_subsampling == 1 &&
1590 descriptor->component_depth == 8) {
1591 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1596 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1597 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1598 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1599 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1600 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))
1601 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1602 st->codec->channels = descriptor->channels;
1603 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1605 if (descriptor->sample_rate.den > 0) {
1606 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1607 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1609 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1610 "found for stream #%d, time base forced to 1/48000\n",
1611 descriptor->sample_rate.num, descriptor->sample_rate.den,
1613 avpriv_set_pts_info(st, 64, 1, 48000);
1616 /* if duration is set, rescale it from EditRate to SampleRate */
1617 if (st->duration != AV_NOPTS_VALUE)
1618 st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1620 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1621 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1622 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1623 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1624 else if (descriptor->bits_per_sample == 32)
1625 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1626 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1627 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1628 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1629 else if (descriptor->bits_per_sample == 32)
1630 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1631 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1632 st->need_parsing = AVSTREAM_PARSE_FULL;
1635 if (descriptor->extradata) {
1636 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1637 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1639 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1640 ret = ff_generate_avci_extradata(st);
1644 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1645 /* TODO: decode timestamps */
1646 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1655 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1661 return AVERROR(EINVAL);
1663 buf_size = size + size/2 + 1;
1664 *str = av_malloc(buf_size);
1666 return AVERROR(ENOMEM);
1668 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1676 static int mxf_uid_to_str(UID uid, char **str)
1680 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1682 return AVERROR(ENOMEM);
1683 for (i = 0; i < sizeof(UID); i++) {
1684 snprintf(p, 2 + 1, "%.2x", uid[i]);
1686 if (i == 3 || i == 5 || i == 7 || i == 9) {
1687 snprintf(p, 1 + 1, "-");
1694 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1696 struct tm time = {0};
1697 time.tm_year = (timestamp >> 48) - 1900;
1698 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1699 time.tm_mday = (timestamp >> 32 & 0xFF);
1700 time.tm_hour = (timestamp >> 24 & 0xFF);
1701 time.tm_min = (timestamp >> 16 & 0xFF);
1702 time.tm_sec = (timestamp >> 8 & 0xFF);
1704 /* ensure month/day are valid */
1705 time.tm_mon = FFMAX(time.tm_mon, 0);
1706 time.tm_mday = FFMAX(time.tm_mday, 1);
1708 *str = av_mallocz(32);
1710 return AVERROR(ENOMEM);
1711 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1716 #define SET_STR_METADATA(pb, name, str) do { \
1717 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1719 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1722 #define SET_UID_METADATA(pb, name, var, str) do { \
1723 avio_read(pb, var, 16); \
1724 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1726 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1729 #define SET_TS_METADATA(pb, name, var, str) do { \
1730 var = avio_rb64(pb); \
1731 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1733 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1736 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1738 MXFContext *mxf = arg;
1739 AVFormatContext *s = mxf->fc;
1746 SET_STR_METADATA(pb, "company_name", str);
1749 SET_STR_METADATA(pb, "product_name", str);
1752 SET_STR_METADATA(pb, "product_version", str);
1755 SET_UID_METADATA(pb, "product_uid", uid, str);
1758 SET_TS_METADATA(pb, "modification_date", ts, str);
1761 SET_STR_METADATA(pb, "application_platform", str);
1764 SET_UID_METADATA(pb, "generation_uid", uid, str);
1767 SET_UID_METADATA(pb, "uid", uid, str);
1773 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1774 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1775 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1776 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1777 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1778 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1779 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1780 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1781 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1782 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1783 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1784 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1785 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1786 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1787 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1788 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1789 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1790 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1791 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1792 { { 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 */
1793 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1794 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1795 { { 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 */
1796 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1797 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1798 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1799 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1800 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1801 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1802 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1803 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1806 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1808 AVIOContext *pb = mxf->fc->pb;
1809 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1810 uint64_t klv_end = avio_tell(pb) + klv->length;
1813 return AVERROR(ENOMEM);
1814 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1816 int tag = avio_rb16(pb);
1817 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1818 uint64_t next = avio_tell(pb) + size;
1821 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1822 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1823 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1826 if (tag > 0x7FFF) { /* dynamic tag */
1828 for (i = 0; i < mxf->local_tags_count; i++) {
1829 int local_tag = AV_RB16(mxf->local_tags+i*18);
1830 if (local_tag == tag) {
1831 memcpy(uid, mxf->local_tags+i*18+2, 16);
1832 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1833 PRINT_KEY(mxf->fc, "uid", uid);
1837 if (ctx_size && tag == 0x3C0A)
1838 avio_read(pb, ctx->uid, 16);
1839 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1842 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1843 * it extending past the end of the KLV though (zzuf5.mxf). */
1844 if (avio_tell(pb) > klv_end) {
1848 av_log(mxf->fc, AV_LOG_ERROR,
1849 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1851 return AVERROR_INVALIDDATA;
1852 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1853 avio_seek(pb, next, SEEK_SET);
1855 if (ctx_size) ctx->type = type;
1856 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1860 * Seeks to the previous partition, if possible
1861 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1863 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1865 AVIOContext *pb = mxf->fc->pb;
1867 if (!mxf->current_partition ||
1868 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1869 return 0; /* we've parsed all partitions */
1871 /* seek to previous partition */
1872 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1873 mxf->current_partition = NULL;
1875 av_dlog(mxf->fc, "seeking to previous partition\n");
1881 * Called when essence is encountered
1882 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1884 static int mxf_parse_handle_essence(MXFContext *mxf)
1886 AVIOContext *pb = mxf->fc->pb;
1889 if (mxf->parsing_backward) {
1890 return mxf_seek_to_previous_partition(mxf);
1891 } else if (mxf->footer_partition || mxf->last_partition){
1894 offset = mxf->footer_partition ? mxf->footer_partition : mxf->last_partition;
1896 av_dlog(mxf->fc, "seeking to last partition\n");
1898 /* remember where we were so we don't end up seeking further back than this */
1899 mxf->last_forward_tell = avio_tell(pb);
1901 if (!pb->seekable) {
1902 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1906 /* seek to last partition and parse backward */
1907 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1908 av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to last partition @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1909 mxf->run_in + offset, ret);
1913 mxf->current_partition = NULL;
1914 mxf->parsing_backward = 1;
1916 av_dlog(mxf->fc, "can't find last partition\n");
1924 * Called when the next partition or EOF is encountered
1925 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1927 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1929 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1933 * Figures out the proper offset and length of the essence container in each partition
1935 static void mxf_compute_essence_containers(MXFContext *mxf)
1939 /* everything is already correct */
1940 if (mxf->op == OPAtom)
1943 for (x = 0; x < mxf->partitions_count; x++) {
1944 MXFPartition *p = &mxf->partitions[x];
1947 continue; /* BodySID == 0 -> no essence */
1949 if (x >= mxf->partitions_count - 1)
1950 break; /* last partition - can't compute length (and we don't need to) */
1952 /* essence container spans to the next partition */
1953 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1955 if (p->essence_length < 0) {
1956 /* next ThisPartition < essence_offset */
1957 p->essence_length = 0;
1958 av_log(mxf->fc, AV_LOG_ERROR,
1959 "partition %i: bad ThisPartition = %"PRIX64"\n",
1960 x+1, mxf->partitions[x+1].this_partition);
1965 static int64_t round_to_kag(int64_t position, int kag_size)
1967 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1968 /* NOTE: kag_size may be any integer between 1 - 2^10 */
1969 int64_t ret = (position / kag_size) * kag_size;
1970 return ret == position ? ret : ret + kag_size;
1973 static int is_pcm(enum AVCodecID codec_id)
1975 /* we only care about "normal" PCM codecs until we get samples */
1976 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1980 * Deal with the case where for some audio atoms EditUnitByteCount is
1981 * very small (2, 4..). In those cases we should read more than one
1982 * sample per call to mxf_read_packet().
1984 static void mxf_handle_small_eubc(AVFormatContext *s)
1986 MXFContext *mxf = s->priv_data;
1988 /* assuming non-OPAtom == frame wrapped
1989 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1990 if (mxf->op != OPAtom)
1993 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1994 if (s->nb_streams != 1 ||
1995 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1996 !is_pcm(s->streams[0]->codec->codec_id) ||
1997 mxf->nb_index_tables != 1 ||
1998 mxf->index_tables[0].nb_segments != 1 ||
1999 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
2002 /* arbitrarily default to 48 kHz PAL audio frame size */
2003 /* TODO: We could compute this from the ratio between the audio
2004 * and video edit rates for 48 kHz NTSC we could use the
2005 * 1802-1802-1802-1802-1801 pattern. */
2006 mxf->edit_units_per_packet = 1920;
2009 static void mxf_read_random_index_pack(AVFormatContext *s)
2011 MXFContext *mxf = s->priv_data;
2016 if (!s->pb->seekable)
2019 file_size = avio_size(s->pb);
2020 avio_seek(s->pb, file_size - 4, SEEK_SET);
2021 length = avio_rb32(s->pb);
2022 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2024 avio_seek(s->pb, file_size - length, SEEK_SET);
2025 if (klv_read_packet(&klv, s->pb) < 0 ||
2026 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2027 klv.length != length - 20)
2030 avio_skip(s->pb, klv.length - 12);
2031 mxf->last_partition = avio_rb64(s->pb);
2034 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2037 static int mxf_read_header(AVFormatContext *s)
2039 MXFContext *mxf = s->priv_data;
2041 int64_t essence_offset = 0;
2042 int64_t last_pos = -1;
2043 uint64_t last_pos_index = 1;
2046 mxf->last_forward_tell = INT64_MAX;
2047 mxf->edit_units_per_packet = 1;
2049 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2050 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2051 return AVERROR_INVALIDDATA;
2053 avio_seek(s->pb, -14, SEEK_CUR);
2055 mxf->run_in = avio_tell(s->pb);
2057 mxf_read_random_index_pack(s);
2059 while (!url_feof(s->pb)) {
2060 const MXFMetadataReadTableEntry *metadata;
2061 if (avio_tell(s->pb) == last_pos) {
2062 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2063 return AVERROR_INVALIDDATA;
2065 if ((1ULL<<61) % last_pos_index++ == 0)
2066 last_pos = avio_tell(s->pb);
2067 if (klv_read_packet(&klv, s->pb) < 0) {
2068 /* EOF - seek to previous partition or stop */
2069 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2075 PRINT_KEY(s, "read header", klv.key);
2076 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2077 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2078 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2079 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2080 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2082 if (!mxf->current_partition) {
2083 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2084 return AVERROR_INVALIDDATA;
2087 if (!mxf->current_partition->essence_offset) {
2088 /* for OP1a we compute essence_offset
2089 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2090 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2091 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2093 int64_t op1a_essence_offset =
2094 round_to_kag(mxf->current_partition->this_partition +
2095 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2096 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2097 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2099 if (mxf->op == OPAtom) {
2100 /* point essence_offset to the actual data
2101 * OPAtom has all the essence in one big KLV
2103 mxf->current_partition->essence_offset = avio_tell(s->pb);
2104 mxf->current_partition->essence_length = klv.length;
2106 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2107 mxf->current_partition->essence_offset = op1a_essence_offset;
2111 if (!essence_offset)
2112 essence_offset = klv.offset;
2114 /* seek to footer, previous partition or stop */
2115 if (mxf_parse_handle_essence(mxf) <= 0)
2118 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2119 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2120 /* next partition pack - keep going, seek to previous partition or stop */
2121 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2123 else if (mxf->parsing_backward)
2125 /* we're still parsing forward. proceed to parsing this partition pack */
2128 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2129 if (IS_KLV_KEY(klv.key, metadata->key)) {
2131 if (klv.key[5] == 0x53) {
2132 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2134 uint64_t next = avio_tell(s->pb) + klv.length;
2135 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2137 /* only seek forward, else this can loop for a long time */
2138 if (avio_tell(s->pb) > next) {
2139 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2141 return AVERROR_INVALIDDATA;
2144 avio_seek(s->pb, next, SEEK_SET);
2147 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2153 if (!metadata->read)
2154 avio_skip(s->pb, klv.length);
2156 /* FIXME avoid seek */
2157 if (!essence_offset) {
2158 av_log(s, AV_LOG_ERROR, "no essence\n");
2159 return AVERROR_INVALIDDATA;
2161 avio_seek(s->pb, essence_offset, SEEK_SET);
2163 mxf_compute_essence_containers(mxf);
2165 /* we need to do this before computing the index tables
2166 * to be able to fill in zero IndexDurations with st->duration */
2167 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2170 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2173 if (mxf->nb_index_tables > 1) {
2174 /* TODO: look up which IndexSID to use via EssenceContainerData */
2175 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2176 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2177 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2178 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2179 ret = AVERROR_INVALIDDATA;
2183 mxf_handle_small_eubc(s);
2193 * Sets mxf->current_edit_unit based on what offset we're currently at.
2194 * @return next_ofs if OK, <0 on error
2196 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2198 int64_t last_ofs = -1, next_ofs = -1;
2199 MXFIndexTable *t = &mxf->index_tables[0];
2201 /* this is called from the OP1a demuxing logic, which means there
2202 * may be no index tables */
2203 if (mxf->nb_index_tables <= 0)
2206 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2207 while (mxf->current_edit_unit >= 0) {
2208 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2211 if (next_ofs <= last_ofs) {
2212 /* large next_ofs didn't change or current_edit_unit wrapped
2213 * around this fixes the infinite loop on zzuf3.mxf */
2214 av_log(mxf->fc, AV_LOG_ERROR,
2215 "next_ofs didn't change. not deriving packet timestamps\n");
2219 if (next_ofs > current_offset)
2222 last_ofs = next_ofs;
2223 mxf->current_edit_unit++;
2226 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2227 if (mxf->current_edit_unit < 0)
2233 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2235 int i, total = 0, size = 0;
2236 AVStream *st = mxf->fc->streams[stream_index];
2237 MXFTrack *track = st->priv_data;
2238 AVRational time_base = av_inv_q(track->edit_rate);
2239 AVRational sample_rate = av_inv_q(st->time_base);
2240 const MXFSamplesPerFrame *spf = NULL;
2242 if ((sample_rate.num / sample_rate.den) == 48000)
2243 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2245 int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2246 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2247 av_mul_q(sample_rate, time_base)));
2249 av_log(mxf->fc, AV_LOG_WARNING,
2250 "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2251 stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2255 while (spf->samples_per_frame[size]) {
2256 total += spf->samples_per_frame[size];
2262 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2263 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2264 *sample_count += spf->samples_per_frame[i];
2270 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2272 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2273 pkt->pts = track->sample_count;
2274 if ( codec->channels <= 0
2275 || av_get_bits_per_sample(codec->codec_id) <= 0
2276 || codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) < 8)
2277 return AVERROR(EINVAL);
2278 track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2282 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2285 MXFContext *mxf = s->priv_data;
2287 while (klv_read_packet(&klv, s->pb) == 0) {
2289 PRINT_KEY(s, "read packet", klv.key);
2290 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2291 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2292 ret = mxf_decrypt_triplet(s, pkt, &klv);
2294 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2295 return AVERROR_INVALIDDATA;
2299 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2300 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2301 int index = mxf_get_stream_index(s, &klv);
2302 int64_t next_ofs, next_klv;
2305 AVCodecContext *codec;
2308 av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2312 st = s->streams[index];
2313 track = st->priv_data;
2315 if (s->streams[index]->discard == AVDISCARD_ALL)
2318 next_klv = avio_tell(s->pb) + klv.length;
2319 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2321 if (next_ofs >= 0 && next_klv > next_ofs) {
2322 /* if this check is hit then it's possible OPAtom was treated as OP1a
2323 * truncate the packet since it's probably very large (>2 GiB is common) */
2324 avpriv_request_sample(s,
2325 "OPAtom misinterpreted as OP1a?"
2326 "KLV for edit unit %i extending into "
2328 mxf->current_edit_unit);
2329 klv.length = next_ofs - avio_tell(s->pb);
2332 /* check for 8 channels AES3 element */
2333 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2334 if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2335 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2336 return AVERROR_INVALIDDATA;
2339 ret = av_get_packet(s->pb, pkt, klv.length);
2343 pkt->stream_index = index;
2344 pkt->pos = klv.offset;
2346 codec = s->streams[index]->codec;
2347 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2348 /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2349 MXFIndexTable *t = &mxf->index_tables[0];
2351 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2352 pkt->dts = mxf->current_edit_unit + t->first_dts;
2353 pkt->pts = t->ptses[mxf->current_edit_unit];
2354 } else if (track->intra_only) {
2355 /* intra-only -> PTS = EditUnit.
2356 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2357 pkt->pts = mxf->current_edit_unit;
2359 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2360 int ret = mxf_set_audio_pts(mxf, codec, pkt);
2365 /* seek for truncated packets */
2366 avio_seek(s->pb, next_klv, SEEK_SET);
2371 avio_skip(s->pb, klv.length);
2373 return url_feof(s->pb) ? AVERROR_EOF : -1;
2376 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2378 MXFContext *mxf = s->priv_data;
2380 int64_t ret64, pos, next_pos;
2385 if (mxf->op != OPAtom)
2386 return mxf_read_packet_old(s, pkt);
2388 /* OPAtom - clip wrapped demuxing */
2389 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2391 t = &mxf->index_tables[0];
2393 if (mxf->current_edit_unit >= st->duration)
2396 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2398 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2401 /* compute size by finding the next edit unit or the end of the essence container
2402 * not pretty, but it works */
2403 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2404 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2405 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2406 return AVERROR_INVALIDDATA;
2409 if ((size = next_pos - pos) <= 0) {
2410 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2411 return AVERROR_INVALIDDATA;
2414 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2417 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2420 pkt->stream_index = 0;
2422 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2423 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2424 pkt->dts = mxf->current_edit_unit + t->first_dts;
2425 pkt->pts = t->ptses[mxf->current_edit_unit];
2426 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2427 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2432 mxf->current_edit_unit += edit_units;
2437 static int mxf_read_close(AVFormatContext *s)
2439 MXFContext *mxf = s->priv_data;
2440 MXFIndexTableSegment *seg;
2443 av_freep(&mxf->packages_refs);
2445 for (i = 0; i < s->nb_streams; i++)
2446 s->streams[i]->priv_data = NULL;
2448 for (i = 0; i < mxf->metadata_sets_count; i++) {
2449 switch (mxf->metadata_sets[i]->type) {
2451 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2453 case MultipleDescriptor:
2454 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2457 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2460 case MaterialPackage:
2461 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2463 case IndexTableSegment:
2464 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2465 av_freep(&seg->temporal_offset_entries);
2466 av_freep(&seg->flag_entries);
2467 av_freep(&seg->stream_offset_entries);
2472 av_freep(&mxf->metadata_sets[i]);
2474 av_freep(&mxf->partitions);
2475 av_freep(&mxf->metadata_sets);
2476 av_freep(&mxf->aesc);
2477 av_freep(&mxf->local_tags);
2479 if (mxf->index_tables) {
2480 for (i = 0; i < mxf->nb_index_tables; i++) {
2481 av_freep(&mxf->index_tables[i].segments);
2482 av_freep(&mxf->index_tables[i].ptses);
2483 av_freep(&mxf->index_tables[i].fake_index);
2486 av_freep(&mxf->index_tables);
2491 static int mxf_probe(AVProbeData *p) {
2492 const uint8_t *bufp = p->buf;
2493 const uint8_t *end = p->buf + p->buf_size;
2495 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2498 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2499 end -= sizeof(mxf_header_partition_pack_key);
2501 for (; bufp < end;) {
2502 if (!((bufp[13] - 1) & 0xF2)){
2503 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2504 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2505 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2506 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2507 return AVPROBE_SCORE_MAX;
2516 /* rudimentary byte seek */
2517 /* XXX: use MXF Index */
2518 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2520 AVStream *st = s->streams[stream_index];
2522 MXFContext* mxf = s->priv_data;
2526 MXFTrack *source_track = st->priv_data;
2528 /* if audio then truncate sample_time to EditRate */
2529 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2530 sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2532 if (mxf->nb_index_tables <= 0) {
2534 return AVERROR_INVALIDDATA;
2535 if (sample_time < 0)
2537 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2539 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2543 ff_update_cur_dts(s, st, sample_time);
2544 mxf->current_edit_unit = sample_time;
2546 t = &mxf->index_tables[0];
2548 /* clamp above zero, else ff_index_search_timestamp() returns negative
2549 * this also means we allow seeking before the start */
2550 sample_time = FFMAX(sample_time, 0);
2552 if (t->fake_index) {
2553 /* behave as if we have a proper index */
2554 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2557 /* no IndexEntryArray (one or more CBR segments)
2558 * make sure we don't seek past the end */
2559 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2562 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2565 ff_update_cur_dts(s, st, sample_time);
2566 mxf->current_edit_unit = sample_time;
2567 avio_seek(s->pb, seekpos, SEEK_SET);
2570 // Update all tracks sample count
2571 for (i = 0; i < s->nb_streams; i++) {
2572 AVStream *cur_st = s->streams[i];
2573 MXFTrack *cur_track = cur_st->priv_data;
2574 uint64_t current_sample_count = 0;
2575 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2576 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2580 cur_track->sample_count = current_sample_count;
2586 AVInputFormat ff_mxf_demuxer = {
2588 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2589 .priv_data_size = sizeof(MXFContext),
2590 .read_probe = mxf_probe,
2591 .read_header = mxf_read_header,
2592 .read_packet = mxf_read_packet,
2593 .read_close = mxf_read_close,
2594 .read_seek = mxf_read_seek,