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 */
154 unsigned int component_depth;
155 unsigned int horiz_subsampling;
156 unsigned int vert_subsampling;
157 UID *sub_descriptors_refs;
158 int sub_descriptors_count;
162 enum AVPixelFormat pix_fmt;
167 enum MXFMetadataSetType type;
168 int edit_unit_byte_count;
171 AVRational index_edit_rate;
172 uint64_t index_start_position;
173 uint64_t index_duration;
174 int8_t *temporal_offset_entries;
176 uint64_t *stream_offset_entries;
177 int nb_index_entries;
178 } MXFIndexTableSegment;
182 enum MXFMetadataSetType type;
186 MXFDescriptor *descriptor; /* only one */
192 enum MXFMetadataSetType type;
195 /* decoded index table */
199 int nb_ptses; /* number of PTSes or total duration of index */
200 int64_t first_dts; /* DTS = EditUnit + first_dts */
201 int64_t *ptses; /* maps EditUnit -> PTS */
203 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
204 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
208 MXFPartition *partitions;
209 unsigned partitions_count;
213 MXFMetadataSet **metadata_sets;
214 int metadata_sets_count;
218 int local_tags_count;
219 uint64_t last_partition;
220 uint64_t footer_partition;
221 KLVPacket current_klv_data;
222 int current_klv_index;
224 MXFPartition *current_partition;
225 int parsing_backward;
226 int64_t last_forward_tell;
227 int last_forward_partition;
228 int current_edit_unit;
230 MXFIndexTable *index_tables;
231 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
234 enum MXFWrappingScheme {
239 /* NOTE: klv_offset is not set (-1) for local keys */
240 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
244 MXFMetadataReadFunc *read;
246 enum MXFMetadataSetType type;
247 } MXFMetadataReadTableEntry;
249 static int mxf_read_close(AVFormatContext *s);
251 /* partial keys to match */
252 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
253 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
254 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
255 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
256 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
257 /* complete keys to match */
258 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 };
259 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
260 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
261 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 };
262 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
264 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
266 static int64_t klv_decode_ber_length(AVIOContext *pb)
268 uint64_t size = avio_r8(pb);
269 if (size & 0x80) { /* long form */
270 int bytes_num = size & 0x7f;
271 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
273 return AVERROR_INVALIDDATA;
276 size = size << 8 | avio_r8(pb);
281 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
284 for (i = 0; i < size && !url_feof(pb); i++) {
288 else if (b != key[i])
294 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
296 if (!mxf_read_sync(pb, mxf_klv_key, 4))
297 return AVERROR_INVALIDDATA;
298 klv->offset = avio_tell(pb) - 4;
299 memcpy(klv->key, mxf_klv_key, 4);
300 avio_read(pb, klv->key + 4, 12);
301 klv->length = klv_decode_ber_length(pb);
302 return klv->length == -1 ? -1 : 0;
305 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
309 for (i = 0; i < s->nb_streams; i++) {
310 MXFTrack *track = s->streams[i]->priv_data;
312 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
315 /* return 0 if only one stream, for OP Atom files with 0 as track number */
316 return s->nb_streams == 1 ? 0 : -1;
319 /* XXX: use AVBitStreamFilter */
320 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
322 const uint8_t *buf_ptr, *end_ptr;
326 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
327 return AVERROR_INVALIDDATA;
328 length = av_get_packet(pb, pkt, length);
331 data_ptr = pkt->data;
332 end_ptr = pkt->data + length;
333 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
334 for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
335 for (i = 0; i < st->codec->channels; i++) {
336 uint32_t sample = bytestream_get_le32(&buf_ptr);
337 if (st->codec->bits_per_coded_sample == 24)
338 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
340 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
342 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
344 av_shrink_packet(pkt, data_ptr - pkt->data);
348 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
350 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
351 MXFContext *mxf = s->priv_data;
352 AVIOContext *pb = s->pb;
353 int64_t end = avio_tell(pb) + klv->length;
356 uint64_t plaintext_size;
361 if (!mxf->aesc && s->key && s->keylen == 16) {
362 mxf->aesc = av_aes_alloc();
364 return AVERROR(ENOMEM);
365 av_aes_init(mxf->aesc, s->key, 128, 1);
368 avio_skip(pb, klv_decode_ber_length(pb));
370 klv_decode_ber_length(pb);
371 plaintext_size = avio_rb64(pb);
373 klv_decode_ber_length(pb);
374 avio_read(pb, klv->key, 16);
375 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
376 return AVERROR_INVALIDDATA;
377 index = mxf_get_stream_index(s, klv);
379 return AVERROR_INVALIDDATA;
381 klv_decode_ber_length(pb);
382 orig_size = avio_rb64(pb);
383 if (orig_size < plaintext_size)
384 return AVERROR_INVALIDDATA;
386 size = klv_decode_ber_length(pb);
387 if (size < 32 || size - 32 < orig_size)
388 return AVERROR_INVALIDDATA;
389 avio_read(pb, ivec, 16);
390 avio_read(pb, tmpbuf, 16);
392 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
393 if (memcmp(tmpbuf, checkv, 16))
394 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
396 size = av_get_packet(pb, pkt, size);
399 else if (size < plaintext_size)
400 return AVERROR_INVALIDDATA;
401 size -= plaintext_size;
403 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
404 &pkt->data[plaintext_size], size >> 4, ivec, 1);
405 av_shrink_packet(pkt, orig_size);
406 pkt->stream_index = index;
407 avio_skip(pb, end - avio_tell(pb));
411 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
413 MXFContext *mxf = arg;
414 int item_num = avio_rb32(pb);
415 int item_len = avio_rb32(pb);
417 if (item_len != 18) {
418 avpriv_request_sample(pb, "Primer pack item length %d", item_len);
419 return AVERROR_PATCHWELCOME;
421 if (item_num > 65536) {
422 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
423 return AVERROR_INVALIDDATA;
425 mxf->local_tags = av_calloc(item_num, item_len);
426 if (!mxf->local_tags)
427 return AVERROR(ENOMEM);
428 mxf->local_tags_count = item_num;
429 avio_read(pb, mxf->local_tags, item_num*item_len);
433 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
435 MXFContext *mxf = arg;
436 MXFPartition *partition, *tmp_part;
438 uint64_t footer_partition;
439 uint32_t nb_essence_containers;
441 tmp_part = av_realloc_array(mxf->partitions, mxf->partitions_count + 1, sizeof(*mxf->partitions));
443 return AVERROR(ENOMEM);
444 mxf->partitions = tmp_part;
446 if (mxf->parsing_backward) {
447 /* insert the new partition pack in the middle
448 * this makes the entries in mxf->partitions sorted by offset */
449 memmove(&mxf->partitions[mxf->last_forward_partition+1],
450 &mxf->partitions[mxf->last_forward_partition],
451 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
452 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
454 mxf->last_forward_partition++;
455 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
458 memset(partition, 0, sizeof(*partition));
459 mxf->partitions_count++;
460 partition->pack_length = avio_tell(pb) - klv_offset + size;
464 partition->type = Header;
467 partition->type = BodyPartition;
470 partition->type = Footer;
473 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
474 return AVERROR_INVALIDDATA;
477 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
478 partition->closed = partition->type == Footer || !(uid[14] & 1);
479 partition->complete = uid[14] > 2;
481 partition->kag_size = avio_rb32(pb);
482 partition->this_partition = avio_rb64(pb);
483 partition->previous_partition = avio_rb64(pb);
484 footer_partition = avio_rb64(pb);
485 partition->header_byte_count = avio_rb64(pb);
486 partition->index_byte_count = avio_rb64(pb);
487 partition->index_sid = avio_rb32(pb);
489 partition->body_sid = avio_rb32(pb);
490 avio_read(pb, op, sizeof(UID));
491 nb_essence_containers = avio_rb32(pb);
493 /* some files don'thave FooterPartition set in every partition */
494 if (footer_partition) {
495 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
496 av_log(mxf->fc, AV_LOG_ERROR,
497 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
498 mxf->footer_partition, footer_partition);
500 mxf->footer_partition = footer_partition;
505 "PartitionPack: ThisPartition = 0x%"PRIX64
506 ", PreviousPartition = 0x%"PRIX64", "
507 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
508 partition->this_partition,
509 partition->previous_partition, footer_partition,
510 partition->index_sid, partition->body_sid);
512 /* sanity check PreviousPartition if set */
513 if (partition->previous_partition &&
514 mxf->run_in + partition->previous_partition >= klv_offset) {
515 av_log(mxf->fc, AV_LOG_ERROR,
516 "PreviousPartition points to this partition or forward\n");
517 return AVERROR_INVALIDDATA;
520 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
521 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
522 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
523 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
524 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
525 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
526 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
527 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
528 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
529 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
530 else if (op[12] == 0x10) {
531 /* SMPTE 390m: "There shall be exactly one essence container"
532 * The following block deals with files that violate this, namely:
533 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
534 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
535 if (nb_essence_containers != 1) {
536 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
540 av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
541 nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
547 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
551 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
552 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
554 if (mxf->op == OPSONYOpt)
555 partition->kag_size = 512;
557 partition->kag_size = 1;
559 av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
565 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
567 MXFMetadataSet **tmp;
569 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
571 return AVERROR(ENOMEM);
572 mxf->metadata_sets = tmp;
573 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
574 mxf->metadata_sets_count++;
578 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
580 MXFCryptoContext *cryptocontext = arg;
582 return AVERROR_INVALIDDATA;
583 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
584 avio_read(pb, cryptocontext->source_container_ul, 16);
588 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
590 MXFContext *mxf = arg;
593 mxf->packages_count = avio_rb32(pb);
594 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
595 if (!mxf->packages_refs)
596 return AVERROR(ENOMEM);
597 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
598 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
604 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
606 MXFStructuralComponent *source_clip = arg;
609 source_clip->duration = avio_rb64(pb);
612 source_clip->start_position = avio_rb64(pb);
615 /* UMID, only get last 16 bytes */
617 avio_read(pb, source_clip->source_package_uid, 16);
620 source_clip->source_track_id = avio_rb32(pb);
626 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
628 MXFPackage *package = arg;
631 package->tracks_count = avio_rb32(pb);
632 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
633 if (!package->tracks_refs)
634 return AVERROR(ENOMEM);
635 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
636 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
642 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
644 MXFTimecodeComponent *mxf_timecode = arg;
647 mxf_timecode->start_frame = avio_rb64(pb);
650 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
653 mxf_timecode->drop_frame = avio_r8(pb);
659 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
661 MXFTrack *track = arg;
664 track->track_id = avio_rb32(pb);
667 avio_read(pb, track->track_number, 4);
670 track->edit_rate.num = avio_rb32(pb);
671 track->edit_rate.den = avio_rb32(pb);
674 avio_read(pb, track->sequence_ref, 16);
680 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
682 MXFSequence *sequence = arg;
685 sequence->duration = avio_rb64(pb);
688 avio_read(pb, sequence->data_definition_ul, 16);
691 sequence->structural_components_count = avio_rb32(pb);
692 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
693 if (!sequence->structural_components_refs)
694 return AVERROR(ENOMEM);
695 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
696 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
702 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
704 MXFPackage *package = arg;
707 package->tracks_count = avio_rb32(pb);
708 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
709 if (!package->tracks_refs)
710 return AVERROR(ENOMEM);
711 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
712 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
715 /* UMID, only get last 16 bytes */
717 avio_read(pb, package->package_uid, 16);
720 avio_read(pb, package->descriptor_ref, 16);
726 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
730 segment->nb_index_entries = avio_rb32(pb);
732 length = avio_rb32(pb);
734 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
735 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
736 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
737 return AVERROR(ENOMEM);
739 for (i = 0; i < segment->nb_index_entries; i++) {
740 segment->temporal_offset_entries[i] = avio_r8(pb);
741 avio_r8(pb); /* KeyFrameOffset */
742 segment->flag_entries[i] = avio_r8(pb);
743 segment->stream_offset_entries[i] = avio_rb64(pb);
744 avio_skip(pb, length - 11);
749 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
751 MXFIndexTableSegment *segment = arg;
754 segment->edit_unit_byte_count = avio_rb32(pb);
755 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
758 segment->index_sid = avio_rb32(pb);
759 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
762 segment->body_sid = avio_rb32(pb);
763 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
766 av_dlog(NULL, "IndexEntryArray found\n");
767 return mxf_read_index_entry_array(pb, segment);
769 segment->index_edit_rate.num = avio_rb32(pb);
770 segment->index_edit_rate.den = avio_rb32(pb);
771 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
772 segment->index_edit_rate.den);
775 segment->index_start_position = avio_rb64(pb);
776 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
779 segment->index_duration = avio_rb64(pb);
780 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
786 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
788 int code, value, ofs = 0;
789 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
794 av_dlog(NULL, "pixel layout: code %#x\n", code);
797 layout[ofs++] = code;
798 layout[ofs++] = value;
800 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
801 } while (code != 0); /* SMPTE 377M E.2.46 */
803 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
806 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
808 MXFDescriptor *descriptor = arg;
809 descriptor->pix_fmt = AV_PIX_FMT_NONE;
812 descriptor->sub_descriptors_count = avio_rb32(pb);
813 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
814 if (!descriptor->sub_descriptors_refs)
815 return AVERROR(ENOMEM);
816 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
817 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
820 avio_read(pb, descriptor->essence_container_ul, 16);
823 descriptor->linked_track_id = avio_rb32(pb);
825 case 0x3201: /* PictureEssenceCoding */
826 avio_read(pb, descriptor->essence_codec_ul, 16);
829 descriptor->width = avio_rb32(pb);
832 descriptor->height = avio_rb32(pb);
835 descriptor->frame_layout = avio_r8(pb);
838 descriptor->aspect_ratio.num = avio_rb32(pb);
839 descriptor->aspect_ratio.den = avio_rb32(pb);
842 descriptor->field_dominance = avio_r8(pb);
845 descriptor->component_depth = avio_rb32(pb);
848 descriptor->horiz_subsampling = avio_rb32(pb);
851 descriptor->vert_subsampling = avio_rb32(pb);
854 descriptor->sample_rate.num = avio_rb32(pb);
855 descriptor->sample_rate.den = avio_rb32(pb);
857 case 0x3D06: /* SoundEssenceCompression */
858 avio_read(pb, descriptor->essence_codec_ul, 16);
861 descriptor->channels = avio_rb32(pb);
864 descriptor->bits_per_sample = avio_rb32(pb);
867 mxf_read_pixel_layout(pb, descriptor);
870 /* Private uid used by SONY C0023S01.mxf */
871 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
872 if (descriptor->extradata)
873 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
874 av_free(descriptor->extradata);
875 descriptor->extradata_size = 0;
876 descriptor->extradata = av_malloc(size);
877 if (!descriptor->extradata)
878 return AVERROR(ENOMEM);
879 descriptor->extradata_size = size;
880 avio_read(pb, descriptor->extradata, size);
888 * Match an uid independently of the version byte and up to len common bytes
891 static int mxf_match_uid(const UID key, const UID uid, int len)
894 for (i = 0; i < len; i++) {
895 if (i != 7 && key[i] != uid[i])
901 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
903 while (uls->uid[0]) {
904 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
911 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
917 for (i = 0; i < mxf->metadata_sets_count; i++) {
918 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
919 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
920 return mxf->metadata_sets[i];
926 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
927 // video essence container uls
928 { { 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 */
929 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
930 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
931 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
934 /* EC ULs for intra-only formats */
935 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
936 { { 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 */
937 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
940 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
941 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
942 { { 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 */
943 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
944 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
947 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
948 // sound essence container uls
949 { { 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 */
950 { { 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 */
951 { { 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 */
952 { { 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 */
953 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
956 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
958 int i, j, nb_segments = 0;
959 MXFIndexTableSegment **unsorted_segments;
960 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
962 /* count number of segments, allocate arrays and copy unsorted segments */
963 for (i = 0; i < mxf->metadata_sets_count; i++)
964 if (mxf->metadata_sets[i]->type == IndexTableSegment)
968 return AVERROR_INVALIDDATA;
970 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
971 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
972 av_freep(sorted_segments);
973 av_free(unsorted_segments);
974 return AVERROR(ENOMEM);
977 for (i = j = 0; i < mxf->metadata_sets_count; i++)
978 if (mxf->metadata_sets[i]->type == IndexTableSegment)
979 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
981 *nb_sorted_segments = 0;
983 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
984 for (i = 0; i < nb_segments; i++) {
985 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
986 uint64_t best_index_duration = 0;
988 for (j = 0; j < nb_segments; j++) {
989 MXFIndexTableSegment *s = unsorted_segments[j];
991 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
992 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
993 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
995 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
996 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
997 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
999 best_body_sid = s->body_sid;
1000 best_index_sid = s->index_sid;
1001 best_index_start = s->index_start_position;
1002 best_index_duration = s->index_duration;
1006 /* no suitable entry found -> we're done */
1010 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1011 last_body_sid = best_body_sid;
1012 last_index_sid = best_index_sid;
1013 last_index_start = best_index_start;
1016 av_free(unsorted_segments);
1022 * Computes the absolute file offset of the given essence container offset
1024 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1027 int64_t offset_in = offset; /* for logging */
1029 for (x = 0; x < mxf->partitions_count; x++) {
1030 MXFPartition *p = &mxf->partitions[x];
1032 if (p->body_sid != body_sid)
1035 if (offset < p->essence_length || !p->essence_length) {
1036 *offset_out = p->essence_offset + offset;
1040 offset -= p->essence_length;
1043 av_log(mxf->fc, AV_LOG_ERROR,
1044 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1045 offset_in, body_sid);
1047 return AVERROR_INVALIDDATA;
1051 * Returns the end position of the essence container with given BodySID, or zero if unknown
1053 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1058 for (x = 0; x < mxf->partitions_count; x++) {
1059 MXFPartition *p = &mxf->partitions[x];
1061 if (p->body_sid != body_sid)
1064 if (!p->essence_length)
1067 ret = p->essence_offset + p->essence_length;
1073 /* EditUnit -> absolute offset */
1074 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)
1077 int64_t offset_temp = 0;
1079 for (i = 0; i < index_table->nb_segments; i++) {
1080 MXFIndexTableSegment *s = index_table->segments[i];
1082 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1084 if (edit_unit < s->index_start_position + s->index_duration) {
1085 int64_t index = edit_unit - s->index_start_position;
1087 if (s->edit_unit_byte_count)
1088 offset_temp += s->edit_unit_byte_count * index;
1089 else if (s->nb_index_entries) {
1090 if (s->nb_index_entries == 2 * s->index_duration + 1)
1091 index *= 2; /* Avid index */
1093 if (index < 0 || index >= s->nb_index_entries) {
1094 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1095 index_table->index_sid, s->index_start_position);
1096 return AVERROR_INVALIDDATA;
1099 offset_temp = s->stream_offset_entries[index];
1101 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1102 index_table->index_sid, s->index_start_position);
1103 return AVERROR_INVALIDDATA;
1107 *edit_unit_out = edit_unit;
1109 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1111 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1112 offset_temp += s->edit_unit_byte_count * s->index_duration;
1117 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);
1119 return AVERROR_INVALIDDATA;
1122 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1125 int8_t max_temporal_offset = -128;
1127 /* first compute how many entries we have */
1128 for (i = 0; i < index_table->nb_segments; i++) {
1129 MXFIndexTableSegment *s = index_table->segments[i];
1131 if (!s->nb_index_entries) {
1132 index_table->nb_ptses = 0;
1133 return 0; /* no TemporalOffsets */
1136 index_table->nb_ptses += s->index_duration;
1139 /* paranoid check */
1140 if (index_table->nb_ptses <= 0)
1143 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1144 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1145 av_freep(&index_table->ptses);
1146 return AVERROR(ENOMEM);
1149 /* we may have a few bad TemporalOffsets
1150 * make sure the corresponding PTSes don't have the bogus value 0 */
1151 for (x = 0; x < index_table->nb_ptses; x++)
1152 index_table->ptses[x] = AV_NOPTS_VALUE;
1166 * We want to transform it into this:
1177 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1178 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1179 * The latter makes DTS <= PTS.
1181 for (i = x = 0; i < index_table->nb_segments; i++) {
1182 MXFIndexTableSegment *s = index_table->segments[i];
1183 int index_delta = 1;
1184 int n = s->nb_index_entries;
1186 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1187 index_delta = 2; /* Avid index */
1188 /* ignore the last entry - it's the size of the essence container */
1192 for (j = 0; j < n; j += index_delta, x++) {
1193 int offset = s->temporal_offset_entries[j] / index_delta;
1194 int index = x + offset;
1196 if (x >= index_table->nb_ptses) {
1197 av_log(mxf->fc, AV_LOG_ERROR,
1198 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1199 s->nb_index_entries, s->index_duration);
1203 index_table->fake_index[x].timestamp = x;
1204 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1206 if (index < 0 || index >= index_table->nb_ptses) {
1207 av_log(mxf->fc, AV_LOG_ERROR,
1208 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1213 index_table->ptses[index] = x;
1214 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1218 index_table->first_dts = -max_temporal_offset;
1224 * Sorts and collects index table segments into index tables.
1225 * Also computes PTSes if possible.
1227 static int mxf_compute_index_tables(MXFContext *mxf)
1229 int i, j, k, ret, nb_sorted_segments;
1230 MXFIndexTableSegment **sorted_segments = NULL;
1232 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1233 nb_sorted_segments <= 0) {
1234 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1238 /* sanity check and count unique BodySIDs/IndexSIDs */
1239 for (i = 0; i < nb_sorted_segments; i++) {
1240 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1241 mxf->nb_index_tables++;
1242 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1243 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1244 ret = AVERROR_INVALIDDATA;
1245 goto finish_decoding_index;
1249 if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1250 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1251 ret = AVERROR(ENOMEM);
1252 goto finish_decoding_index;
1255 /* distribute sorted segments to index tables */
1256 for (i = j = 0; i < nb_sorted_segments; i++) {
1257 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1262 mxf->index_tables[j].nb_segments++;
1265 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1266 MXFIndexTable *t = &mxf->index_tables[j];
1268 if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1269 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1270 ret = AVERROR(ENOMEM);
1271 goto finish_decoding_index;
1274 if (sorted_segments[i]->index_start_position)
1275 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1276 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1278 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1279 t->index_sid = sorted_segments[i]->index_sid;
1280 t->body_sid = sorted_segments[i]->body_sid;
1282 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1283 goto finish_decoding_index;
1285 /* fix zero IndexDurations */
1286 for (k = 0; k < t->nb_segments; k++) {
1287 if (t->segments[k]->index_duration)
1290 if (t->nb_segments > 1)
1291 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1294 if (mxf->fc->nb_streams <= 0) {
1295 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1299 /* assume the first stream's duration is reasonable
1300 * leave index_duration = 0 on further segments in case we have any (unlikely)
1302 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1308 finish_decoding_index:
1309 av_free(sorted_segments);
1313 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1315 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1316 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1317 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1318 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1321 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1323 char buf[AV_TIMECODE_STR_SIZE];
1324 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1329 static int mxf_parse_structural_metadata(MXFContext *mxf)
1331 MXFPackage *material_package = NULL;
1332 MXFPackage *temp_package = NULL;
1335 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1336 /* TODO: handle multiple material packages (OP3x) */
1337 for (i = 0; i < mxf->packages_count; i++) {
1338 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1339 if (material_package) break;
1341 if (!material_package) {
1342 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1343 return AVERROR_INVALIDDATA;
1346 for (i = 0; i < material_package->tracks_count; i++) {
1347 MXFPackage *source_package = NULL;
1348 MXFTrack *material_track = NULL;
1349 MXFTrack *source_track = NULL;
1350 MXFTrack *temp_track = NULL;
1351 MXFDescriptor *descriptor = NULL;
1352 MXFStructuralComponent *component = NULL;
1353 MXFTimecodeComponent *mxf_tc = NULL;
1354 UID *essence_container_ul = NULL;
1355 const MXFCodecUL *codec_ul = NULL;
1356 const MXFCodecUL *container_ul = NULL;
1357 const MXFCodecUL *pix_fmt_ul = NULL;
1362 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1363 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1367 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1368 mxf_tc = (MXFTimecodeComponent*)component;
1369 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1370 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1371 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1375 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1376 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1380 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1381 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1385 mxf_tc = (MXFTimecodeComponent*)component;
1386 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1387 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1388 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1393 /* TODO: handle multiple source clips */
1394 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1395 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1399 for (k = 0; k < mxf->packages_count; k++) {
1400 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1403 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1404 source_package = temp_package;
1408 if (!source_package) {
1409 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1412 for (k = 0; k < source_package->tracks_count; k++) {
1413 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1414 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1415 ret = AVERROR_INVALIDDATA;
1418 if (temp_track->track_id == component->source_track_id) {
1419 source_track = temp_track;
1423 if (!source_track) {
1424 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1428 if (!source_track || !component)
1431 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1432 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1433 ret = AVERROR_INVALIDDATA;
1437 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1438 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1439 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1440 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1444 st = avformat_new_stream(mxf->fc, NULL);
1446 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1447 ret = AVERROR(ENOMEM);
1450 st->id = source_track->track_id;
1451 st->priv_data = source_track;
1452 source_track->original_duration = st->duration = component->duration;
1453 if (st->duration == -1)
1454 st->duration = AV_NOPTS_VALUE;
1455 st->start_time = component->start_position;
1456 if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1457 av_log(mxf->fc, AV_LOG_WARNING,
1458 "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1459 material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1460 material_track->edit_rate = (AVRational){25, 1};
1462 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1464 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1465 source_track->edit_rate = material_track->edit_rate;
1467 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1468 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1469 st->codec->codec_type = codec_ul->id;
1471 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1472 if (source_package->descriptor) {
1473 if (source_package->descriptor->type == MultipleDescriptor) {
1474 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1475 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1477 if (!sub_descriptor) {
1478 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1481 if (sub_descriptor->linked_track_id == source_track->track_id) {
1482 descriptor = sub_descriptor;
1486 } else if (source_package->descriptor->type == Descriptor)
1487 descriptor = source_package->descriptor;
1490 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1493 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1494 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1495 essence_container_ul = &descriptor->essence_container_ul;
1496 /* HACK: replacing the original key with mxf_encrypted_essence_container
1497 * is not allowed according to s429-6, try to find correct information anyway */
1498 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1499 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1500 for (k = 0; k < mxf->metadata_sets_count; k++) {
1501 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1502 if (metadata->type == CryptoContext) {
1503 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1509 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1510 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1511 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1512 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1513 avcodec_get_name(st->codec->codec_id));
1514 for (k = 0; k < 16; k++) {
1515 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1516 descriptor->essence_codec_ul[k]);
1517 if (!(k+1 & 19) || k == 5)
1518 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1520 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1522 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1523 source_track->intra_only = mxf_is_intra_only(descriptor);
1524 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1525 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1526 st->codec->codec_id = container_ul->id;
1527 st->codec->width = descriptor->width;
1528 st->codec->height = descriptor->height; /* Field height, not frame height */
1529 switch (descriptor->frame_layout) {
1530 case SegmentedFrame:
1531 /* This one is a weird layout I don't fully understand. */
1532 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1535 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1538 /* Every other line is stored and needs to be duplicated. */
1539 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1540 break; /* The correct thing to do here is fall through, but by breaking we might be
1541 able to decode some streams at half the vertical resolution, rather than not al all.
1542 It's also for compatibility with the old behavior. */
1545 case SeparateFields:
1546 st->codec->height *= 2; /* Turn field height into frame height. */
1549 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1551 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1552 st->codec->pix_fmt = descriptor->pix_fmt;
1553 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1554 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1555 &descriptor->essence_codec_ul);
1556 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1557 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1558 /* support files created before RP224v10 by defaulting to UYVY422
1559 if subsampling is 4:2:2 and component depth is 8-bit */
1560 if (descriptor->horiz_subsampling == 2 &&
1561 descriptor->vert_subsampling == 1 &&
1562 descriptor->component_depth == 8) {
1563 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1568 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1569 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1570 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1571 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1572 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))
1573 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1574 st->codec->channels = descriptor->channels;
1575 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1577 if (descriptor->sample_rate.den > 0) {
1578 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1579 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1581 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1582 "found for stream #%d, time base forced to 1/48000\n",
1583 descriptor->sample_rate.num, descriptor->sample_rate.den,
1585 avpriv_set_pts_info(st, 64, 1, 48000);
1588 /* if duration is set, rescale it from EditRate to SampleRate */
1589 if (st->duration != AV_NOPTS_VALUE)
1590 st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1592 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1593 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1594 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1595 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1596 else if (descriptor->bits_per_sample == 32)
1597 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1598 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1599 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1600 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1601 else if (descriptor->bits_per_sample == 32)
1602 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1603 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1604 st->need_parsing = AVSTREAM_PARSE_FULL;
1607 if (descriptor->extradata) {
1608 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1609 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1611 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1612 ret = ff_generate_avci_extradata(st);
1616 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1617 /* TODO: decode timestamps */
1618 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1627 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1633 return AVERROR(EINVAL);
1635 buf_size = size + size/2 + 1;
1636 *str = av_malloc(buf_size);
1638 return AVERROR(ENOMEM);
1640 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1648 static int mxf_uid_to_str(UID uid, char **str)
1652 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1654 return AVERROR(ENOMEM);
1655 for (i = 0; i < sizeof(UID); i++) {
1656 snprintf(p, 2 + 1, "%.2x", uid[i]);
1658 if (i == 3 || i == 5 || i == 7 || i == 9) {
1659 snprintf(p, 1 + 1, "-");
1666 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1668 struct tm time = {0};
1669 time.tm_year = (timestamp >> 48) - 1900;
1670 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1671 time.tm_mday = (timestamp >> 32 & 0xFF);
1672 time.tm_hour = (timestamp >> 24 & 0xFF);
1673 time.tm_min = (timestamp >> 16 & 0xFF);
1674 time.tm_sec = (timestamp >> 8 & 0xFF);
1676 /* ensure month/day are valid */
1677 time.tm_mon = FFMAX(time.tm_mon, 0);
1678 time.tm_mday = FFMAX(time.tm_mday, 1);
1680 *str = av_mallocz(32);
1682 return AVERROR(ENOMEM);
1683 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1688 #define SET_STR_METADATA(pb, name, str) do { \
1689 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1691 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1694 #define SET_UID_METADATA(pb, name, var, str) do { \
1695 avio_read(pb, var, 16); \
1696 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1698 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1701 #define SET_TS_METADATA(pb, name, var, str) do { \
1702 var = avio_rb64(pb); \
1703 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1705 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1708 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1710 MXFContext *mxf = arg;
1711 AVFormatContext *s = mxf->fc;
1718 SET_STR_METADATA(pb, "company_name", str);
1721 SET_STR_METADATA(pb, "product_name", str);
1724 SET_STR_METADATA(pb, "product_version", str);
1727 SET_UID_METADATA(pb, "product_uid", uid, str);
1730 SET_TS_METADATA(pb, "modification_date", ts, str);
1733 SET_STR_METADATA(pb, "application_platform", str);
1736 SET_UID_METADATA(pb, "generation_uid", uid, str);
1739 SET_UID_METADATA(pb, "uid", uid, str);
1745 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1746 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1747 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1748 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1749 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1750 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1751 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1752 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1753 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1754 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1755 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1756 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1757 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1758 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1759 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1760 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1761 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1762 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1763 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1764 { { 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 */
1765 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1766 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1767 { { 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 */
1768 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1769 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1770 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1771 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1772 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1773 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1774 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1775 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1778 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1780 AVIOContext *pb = mxf->fc->pb;
1781 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1782 uint64_t klv_end = avio_tell(pb) + klv->length;
1785 return AVERROR(ENOMEM);
1786 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1788 int tag = avio_rb16(pb);
1789 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1790 uint64_t next = avio_tell(pb) + size;
1793 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1794 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1795 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1798 if (tag > 0x7FFF) { /* dynamic tag */
1800 for (i = 0; i < mxf->local_tags_count; i++) {
1801 int local_tag = AV_RB16(mxf->local_tags+i*18);
1802 if (local_tag == tag) {
1803 memcpy(uid, mxf->local_tags+i*18+2, 16);
1804 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1805 PRINT_KEY(mxf->fc, "uid", uid);
1809 if (ctx_size && tag == 0x3C0A)
1810 avio_read(pb, ctx->uid, 16);
1811 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1814 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1815 * it extending past the end of the KLV though (zzuf5.mxf). */
1816 if (avio_tell(pb) > klv_end) {
1820 av_log(mxf->fc, AV_LOG_ERROR,
1821 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1823 return AVERROR_INVALIDDATA;
1824 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1825 avio_seek(pb, next, SEEK_SET);
1827 if (ctx_size) ctx->type = type;
1828 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1832 * Seeks to the previous partition, if possible
1833 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1835 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1837 AVIOContext *pb = mxf->fc->pb;
1839 if (!mxf->current_partition ||
1840 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1841 return 0; /* we've parsed all partitions */
1843 /* seek to previous partition */
1844 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1845 mxf->current_partition = NULL;
1847 av_dlog(mxf->fc, "seeking to previous partition\n");
1853 * Called when essence is encountered
1854 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1856 static int mxf_parse_handle_essence(MXFContext *mxf)
1858 AVIOContext *pb = mxf->fc->pb;
1861 if (mxf->parsing_backward) {
1862 return mxf_seek_to_previous_partition(mxf);
1863 } else if (mxf->footer_partition || mxf->last_partition){
1866 offset = mxf->footer_partition ? mxf->footer_partition : mxf->last_partition;
1868 av_dlog(mxf->fc, "seeking to last partition\n");
1870 /* remember where we were so we don't end up seeking further back than this */
1871 mxf->last_forward_tell = avio_tell(pb);
1873 if (!pb->seekable) {
1874 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1878 /* seek to last partition and parse backward */
1879 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1880 av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to last partition @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1881 mxf->run_in + offset, ret);
1885 mxf->current_partition = NULL;
1886 mxf->parsing_backward = 1;
1888 av_dlog(mxf->fc, "can't find last partition\n");
1896 * Called when the next partition or EOF is encountered
1897 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1899 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1901 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1905 * Figures out the proper offset and length of the essence container in each partition
1907 static void mxf_compute_essence_containers(MXFContext *mxf)
1911 /* everything is already correct */
1912 if (mxf->op == OPAtom)
1915 for (x = 0; x < mxf->partitions_count; x++) {
1916 MXFPartition *p = &mxf->partitions[x];
1919 continue; /* BodySID == 0 -> no essence */
1921 if (x >= mxf->partitions_count - 1)
1922 break; /* last partition - can't compute length (and we don't need to) */
1924 /* essence container spans to the next partition */
1925 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1927 if (p->essence_length < 0) {
1928 /* next ThisPartition < essence_offset */
1929 p->essence_length = 0;
1930 av_log(mxf->fc, AV_LOG_ERROR,
1931 "partition %i: bad ThisPartition = %"PRIX64"\n",
1932 x+1, mxf->partitions[x+1].this_partition);
1937 static int64_t round_to_kag(int64_t position, int kag_size)
1939 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1940 /* NOTE: kag_size may be any integer between 1 - 2^10 */
1941 int64_t ret = (position / kag_size) * kag_size;
1942 return ret == position ? ret : ret + kag_size;
1945 static int is_pcm(enum AVCodecID codec_id)
1947 /* we only care about "normal" PCM codecs until we get samples */
1948 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1952 * Deal with the case where for some audio atoms EditUnitByteCount is
1953 * very small (2, 4..). In those cases we should read more than one
1954 * sample per call to mxf_read_packet().
1956 static void mxf_handle_small_eubc(AVFormatContext *s)
1958 MXFContext *mxf = s->priv_data;
1960 /* assuming non-OPAtom == frame wrapped
1961 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1962 if (mxf->op != OPAtom)
1965 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1966 if (s->nb_streams != 1 ||
1967 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1968 !is_pcm(s->streams[0]->codec->codec_id) ||
1969 mxf->nb_index_tables != 1 ||
1970 mxf->index_tables[0].nb_segments != 1 ||
1971 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1974 /* arbitrarily default to 48 kHz PAL audio frame size */
1975 /* TODO: We could compute this from the ratio between the audio
1976 * and video edit rates for 48 kHz NTSC we could use the
1977 * 1802-1802-1802-1802-1801 pattern. */
1978 mxf->edit_units_per_packet = 1920;
1981 static void mxf_read_random_index_pack(AVFormatContext *s)
1983 MXFContext *mxf = s->priv_data;
1988 if (!s->pb->seekable)
1991 file_size = avio_size(s->pb);
1992 avio_seek(s->pb, file_size - 4, SEEK_SET);
1993 length = avio_rb32(s->pb);
1994 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
1996 avio_seek(s->pb, file_size - length, SEEK_SET);
1997 if (klv_read_packet(&klv, s->pb) < 0 ||
1998 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
1999 klv.length != length - 20)
2002 avio_skip(s->pb, klv.length - 12);
2003 mxf->last_partition = avio_rb64(s->pb);
2006 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2009 static int mxf_read_header(AVFormatContext *s)
2011 MXFContext *mxf = s->priv_data;
2013 int64_t essence_offset = 0;
2016 mxf->last_forward_tell = INT64_MAX;
2017 mxf->edit_units_per_packet = 1;
2019 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2020 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2021 return AVERROR_INVALIDDATA;
2023 avio_seek(s->pb, -14, SEEK_CUR);
2025 mxf->run_in = avio_tell(s->pb);
2027 mxf_read_random_index_pack(s);
2029 while (!url_feof(s->pb)) {
2030 const MXFMetadataReadTableEntry *metadata;
2032 if (klv_read_packet(&klv, s->pb) < 0) {
2033 /* EOF - seek to previous partition or stop */
2034 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2040 PRINT_KEY(s, "read header", klv.key);
2041 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2042 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2043 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2044 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2045 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2047 if (!mxf->current_partition) {
2048 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2049 return AVERROR_INVALIDDATA;
2052 if (!mxf->current_partition->essence_offset) {
2053 /* for OP1a we compute essence_offset
2054 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2055 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2056 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2058 int64_t op1a_essence_offset =
2059 round_to_kag(mxf->current_partition->this_partition +
2060 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2061 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2062 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2064 if (mxf->op == OPAtom) {
2065 /* point essence_offset to the actual data
2066 * OPAtom has all the essence in one big KLV
2068 mxf->current_partition->essence_offset = avio_tell(s->pb);
2069 mxf->current_partition->essence_length = klv.length;
2071 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2072 mxf->current_partition->essence_offset = op1a_essence_offset;
2076 if (!essence_offset)
2077 essence_offset = klv.offset;
2079 /* seek to footer, previous partition or stop */
2080 if (mxf_parse_handle_essence(mxf) <= 0)
2083 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2084 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2085 /* next partition pack - keep going, seek to previous partition or stop */
2086 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2088 else if (mxf->parsing_backward)
2090 /* we're still parsing forward. proceed to parsing this partition pack */
2093 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2094 if (IS_KLV_KEY(klv.key, metadata->key)) {
2096 if (klv.key[5] == 0x53) {
2097 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2099 uint64_t next = avio_tell(s->pb) + klv.length;
2100 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2102 /* only seek forward, else this can loop for a long time */
2103 if (avio_tell(s->pb) > next) {
2104 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2106 return AVERROR_INVALIDDATA;
2109 avio_seek(s->pb, next, SEEK_SET);
2112 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2118 if (!metadata->read)
2119 avio_skip(s->pb, klv.length);
2121 /* FIXME avoid seek */
2122 if (!essence_offset) {
2123 av_log(s, AV_LOG_ERROR, "no essence\n");
2124 return AVERROR_INVALIDDATA;
2126 avio_seek(s->pb, essence_offset, SEEK_SET);
2128 mxf_compute_essence_containers(mxf);
2130 /* we need to do this before computing the index tables
2131 * to be able to fill in zero IndexDurations with st->duration */
2132 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2135 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2138 if (mxf->nb_index_tables > 1) {
2139 /* TODO: look up which IndexSID to use via EssenceContainerData */
2140 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2141 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2142 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2143 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2144 ret = AVERROR_INVALIDDATA;
2148 mxf_handle_small_eubc(s);
2158 * Sets mxf->current_edit_unit based on what offset we're currently at.
2159 * @return next_ofs if OK, <0 on error
2161 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2163 int64_t last_ofs = -1, next_ofs = -1;
2164 MXFIndexTable *t = &mxf->index_tables[0];
2166 /* this is called from the OP1a demuxing logic, which means there
2167 * may be no index tables */
2168 if (mxf->nb_index_tables <= 0)
2171 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2172 while (mxf->current_edit_unit >= 0) {
2173 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2176 if (next_ofs <= last_ofs) {
2177 /* large next_ofs didn't change or current_edit_unit wrapped
2178 * around this fixes the infinite loop on zzuf3.mxf */
2179 av_log(mxf->fc, AV_LOG_ERROR,
2180 "next_ofs didn't change. not deriving packet timestamps\n");
2184 if (next_ofs > current_offset)
2187 last_ofs = next_ofs;
2188 mxf->current_edit_unit++;
2191 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2192 if (mxf->current_edit_unit < 0)
2198 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2200 int i, total = 0, size = 0;
2201 AVStream *st = mxf->fc->streams[stream_index];
2202 MXFTrack *track = st->priv_data;
2203 AVRational time_base = av_inv_q(track->edit_rate);
2204 AVRational sample_rate = av_inv_q(st->time_base);
2205 const MXFSamplesPerFrame *spf = NULL;
2207 if ((sample_rate.num / sample_rate.den) == 48000)
2208 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2210 int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2211 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2212 av_mul_q(sample_rate, time_base)));
2214 av_log(mxf->fc, AV_LOG_WARNING,
2215 "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2216 stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2220 while (spf->samples_per_frame[size]) {
2221 total += spf->samples_per_frame[size];
2227 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2228 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2229 *sample_count += spf->samples_per_frame[i];
2235 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2237 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2238 pkt->pts = track->sample_count;
2239 if ( codec->channels <= 0
2240 || av_get_bits_per_sample(codec->codec_id) <= 0
2241 || codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) < 8)
2242 return AVERROR(EINVAL);
2243 track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2247 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2250 MXFContext *mxf = s->priv_data;
2252 while (klv_read_packet(&klv, s->pb) == 0) {
2254 PRINT_KEY(s, "read packet", klv.key);
2255 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2256 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2257 ret = mxf_decrypt_triplet(s, pkt, &klv);
2259 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2260 return AVERROR_INVALIDDATA;
2264 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2265 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2266 int index = mxf_get_stream_index(s, &klv);
2267 int64_t next_ofs, next_klv;
2270 AVCodecContext *codec;
2273 av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2277 st = s->streams[index];
2278 track = st->priv_data;
2280 if (s->streams[index]->discard == AVDISCARD_ALL)
2283 next_klv = avio_tell(s->pb) + klv.length;
2284 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2286 if (next_ofs >= 0 && next_klv > next_ofs) {
2287 /* if this check is hit then it's possible OPAtom was treated as OP1a
2288 * truncate the packet since it's probably very large (>2 GiB is common) */
2289 avpriv_request_sample(s,
2290 "OPAtom misinterpreted as OP1a?"
2291 "KLV for edit unit %i extending into "
2293 mxf->current_edit_unit);
2294 klv.length = next_ofs - avio_tell(s->pb);
2297 /* check for 8 channels AES3 element */
2298 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2299 if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2300 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2301 return AVERROR_INVALIDDATA;
2304 ret = av_get_packet(s->pb, pkt, klv.length);
2308 pkt->stream_index = index;
2309 pkt->pos = klv.offset;
2311 codec = s->streams[index]->codec;
2312 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2313 /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2314 MXFIndexTable *t = &mxf->index_tables[0];
2316 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2317 pkt->dts = mxf->current_edit_unit + t->first_dts;
2318 pkt->pts = t->ptses[mxf->current_edit_unit];
2319 } else if (track->intra_only) {
2320 /* intra-only -> PTS = EditUnit.
2321 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2322 pkt->pts = mxf->current_edit_unit;
2324 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2325 int ret = mxf_set_audio_pts(mxf, codec, pkt);
2330 /* seek for truncated packets */
2331 avio_seek(s->pb, next_klv, SEEK_SET);
2336 avio_skip(s->pb, klv.length);
2338 return url_feof(s->pb) ? AVERROR_EOF : -1;
2341 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2343 MXFContext *mxf = s->priv_data;
2345 int64_t ret64, pos, next_pos;
2350 if (mxf->op != OPAtom)
2351 return mxf_read_packet_old(s, pkt);
2353 /* OPAtom - clip wrapped demuxing */
2354 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2356 t = &mxf->index_tables[0];
2358 if (mxf->current_edit_unit >= st->duration)
2361 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2363 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2366 /* compute size by finding the next edit unit or the end of the essence container
2367 * not pretty, but it works */
2368 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2369 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2370 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2371 return AVERROR_INVALIDDATA;
2374 if ((size = next_pos - pos) <= 0) {
2375 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2376 return AVERROR_INVALIDDATA;
2379 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2382 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2385 pkt->stream_index = 0;
2387 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2388 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2389 pkt->dts = mxf->current_edit_unit + t->first_dts;
2390 pkt->pts = t->ptses[mxf->current_edit_unit];
2391 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2392 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2397 mxf->current_edit_unit += edit_units;
2402 static int mxf_read_close(AVFormatContext *s)
2404 MXFContext *mxf = s->priv_data;
2405 MXFIndexTableSegment *seg;
2408 av_freep(&mxf->packages_refs);
2410 for (i = 0; i < s->nb_streams; i++)
2411 s->streams[i]->priv_data = NULL;
2413 for (i = 0; i < mxf->metadata_sets_count; i++) {
2414 switch (mxf->metadata_sets[i]->type) {
2416 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2418 case MultipleDescriptor:
2419 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2422 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2425 case MaterialPackage:
2426 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2428 case IndexTableSegment:
2429 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2430 av_freep(&seg->temporal_offset_entries);
2431 av_freep(&seg->flag_entries);
2432 av_freep(&seg->stream_offset_entries);
2437 av_freep(&mxf->metadata_sets[i]);
2439 av_freep(&mxf->partitions);
2440 av_freep(&mxf->metadata_sets);
2441 av_freep(&mxf->aesc);
2442 av_freep(&mxf->local_tags);
2444 if (mxf->index_tables) {
2445 for (i = 0; i < mxf->nb_index_tables; i++) {
2446 av_freep(&mxf->index_tables[i].segments);
2447 av_freep(&mxf->index_tables[i].ptses);
2448 av_freep(&mxf->index_tables[i].fake_index);
2451 av_freep(&mxf->index_tables);
2456 static int mxf_probe(AVProbeData *p) {
2457 const uint8_t *bufp = p->buf;
2458 const uint8_t *end = p->buf + p->buf_size;
2460 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2463 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2464 end -= sizeof(mxf_header_partition_pack_key);
2466 for (; bufp < end;) {
2467 if (!((bufp[13] - 1) & 0xF2)){
2468 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2469 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2470 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2471 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2472 return AVPROBE_SCORE_MAX;
2481 /* rudimentary byte seek */
2482 /* XXX: use MXF Index */
2483 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2485 AVStream *st = s->streams[stream_index];
2487 MXFContext* mxf = s->priv_data;
2492 MXFTrack *source_track = st->priv_data;
2494 /* if audio then truncate sample_time to EditRate */
2495 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2496 sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2498 if (mxf->nb_index_tables <= 0) {
2500 return AVERROR_INVALIDDATA;
2501 if (sample_time < 0)
2503 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2505 if ((ret64 = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2507 ff_update_cur_dts(s, st, sample_time);
2508 mxf->current_edit_unit = sample_time;
2510 t = &mxf->index_tables[0];
2512 /* clamp above zero, else ff_index_search_timestamp() returns negative
2513 * this also means we allow seeking before the start */
2514 sample_time = FFMAX(sample_time, 0);
2516 if (t->fake_index) {
2517 /* behave as if we have a proper index */
2518 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2521 /* no IndexEntryArray (one or more CBR segments)
2522 * make sure we don't seek past the end */
2523 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2526 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2529 ff_update_cur_dts(s, st, sample_time);
2530 mxf->current_edit_unit = sample_time;
2531 avio_seek(s->pb, seekpos, SEEK_SET);
2534 // Update all tracks sample count
2535 for (i = 0; i < s->nb_streams; i++) {
2536 AVStream *cur_st = s->streams[i];
2537 MXFTrack *cur_track = cur_st->priv_data;
2538 uint64_t current_sample_count = 0;
2539 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2540 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2544 cur_track->sample_count = current_sample_count;
2550 AVInputFormat ff_mxf_demuxer = {
2552 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2553 .priv_data_size = sizeof(MXFContext),
2554 .read_probe = mxf_probe,
2555 .read_header = mxf_read_header,
2556 .read_packet = mxf_read_packet,
2557 .read_close = mxf_read_close,
2558 .read_seek = mxf_read_seek,