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 (; end_ptr - buf_ptr >= st->codec->channels * 4; ) {
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 if (avio_read(pb, op, sizeof(UID)) != sizeof(UID)) {
491 av_log(mxf->fc, AV_LOG_ERROR, "Failed reading UID\n");
492 return AVERROR_INVALIDDATA;
494 nb_essence_containers = avio_rb32(pb);
496 /* some files don'thave FooterPartition set in every partition */
497 if (footer_partition) {
498 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
499 av_log(mxf->fc, AV_LOG_ERROR,
500 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
501 mxf->footer_partition, footer_partition);
503 mxf->footer_partition = footer_partition;
508 "PartitionPack: ThisPartition = 0x%"PRIX64
509 ", PreviousPartition = 0x%"PRIX64", "
510 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
511 partition->this_partition,
512 partition->previous_partition, footer_partition,
513 partition->index_sid, partition->body_sid);
515 /* sanity check PreviousPartition if set */
516 if (partition->previous_partition &&
517 mxf->run_in + partition->previous_partition >= klv_offset) {
518 av_log(mxf->fc, AV_LOG_ERROR,
519 "PreviousPartition points to this partition or forward\n");
520 return AVERROR_INVALIDDATA;
523 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
524 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
525 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
526 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
527 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
528 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
529 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
530 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
531 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
532 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
533 else if (op[12] == 0x10) {
534 /* SMPTE 390m: "There shall be exactly one essence container"
535 * The following block deals with files that violate this, namely:
536 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
537 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
538 if (nb_essence_containers != 1) {
539 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
543 av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
544 nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
550 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
554 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
555 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
557 if (mxf->op == OPSONYOpt)
558 partition->kag_size = 512;
560 partition->kag_size = 1;
562 av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
568 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
570 MXFMetadataSet **tmp;
572 tmp = av_realloc_array(mxf->metadata_sets, mxf->metadata_sets_count + 1, sizeof(*mxf->metadata_sets));
574 return AVERROR(ENOMEM);
575 mxf->metadata_sets = tmp;
576 mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set;
577 mxf->metadata_sets_count++;
581 static int mxf_read_cryptographic_context(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
583 MXFCryptoContext *cryptocontext = arg;
585 return AVERROR_INVALIDDATA;
586 if (IS_KLV_KEY(uid, mxf_crypto_source_container_ul))
587 avio_read(pb, cryptocontext->source_container_ul, 16);
591 static int mxf_read_content_storage(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
593 MXFContext *mxf = arg;
596 mxf->packages_count = avio_rb32(pb);
597 mxf->packages_refs = av_calloc(mxf->packages_count, sizeof(UID));
598 if (!mxf->packages_refs)
599 return AVERROR(ENOMEM);
600 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
601 avio_read(pb, (uint8_t *)mxf->packages_refs, mxf->packages_count * sizeof(UID));
607 static int mxf_read_source_clip(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
609 MXFStructuralComponent *source_clip = arg;
612 source_clip->duration = avio_rb64(pb);
615 source_clip->start_position = avio_rb64(pb);
618 /* UMID, only get last 16 bytes */
620 avio_read(pb, source_clip->source_package_uid, 16);
623 source_clip->source_track_id = avio_rb32(pb);
629 static int mxf_read_material_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
631 MXFPackage *package = arg;
634 package->tracks_count = avio_rb32(pb);
635 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
636 if (!package->tracks_refs)
637 return AVERROR(ENOMEM);
638 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
639 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
645 static int mxf_read_timecode_component(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
647 MXFTimecodeComponent *mxf_timecode = arg;
650 mxf_timecode->start_frame = avio_rb64(pb);
653 mxf_timecode->rate = (AVRational){avio_rb16(pb), 1};
656 mxf_timecode->drop_frame = avio_r8(pb);
662 static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
664 MXFTrack *track = arg;
667 track->track_id = avio_rb32(pb);
670 avio_read(pb, track->track_number, 4);
673 track->edit_rate.num = avio_rb32(pb);
674 track->edit_rate.den = avio_rb32(pb);
677 avio_read(pb, track->sequence_ref, 16);
683 static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
685 MXFSequence *sequence = arg;
688 sequence->duration = avio_rb64(pb);
691 avio_read(pb, sequence->data_definition_ul, 16);
694 sequence->structural_components_count = avio_rb32(pb);
695 sequence->structural_components_refs = av_calloc(sequence->structural_components_count, sizeof(UID));
696 if (!sequence->structural_components_refs)
697 return AVERROR(ENOMEM);
698 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
699 avio_read(pb, (uint8_t *)sequence->structural_components_refs, sequence->structural_components_count * sizeof(UID));
705 static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
707 MXFPackage *package = arg;
710 package->tracks_count = avio_rb32(pb);
711 package->tracks_refs = av_calloc(package->tracks_count, sizeof(UID));
712 if (!package->tracks_refs)
713 return AVERROR(ENOMEM);
714 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
715 avio_read(pb, (uint8_t *)package->tracks_refs, package->tracks_count * sizeof(UID));
718 /* UMID, only get last 16 bytes */
720 avio_read(pb, package->package_uid, 16);
723 avio_read(pb, package->descriptor_ref, 16);
729 static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment)
733 segment->nb_index_entries = avio_rb32(pb);
735 length = avio_rb32(pb);
737 if (!(segment->temporal_offset_entries=av_calloc(segment->nb_index_entries, sizeof(*segment->temporal_offset_entries))) ||
738 !(segment->flag_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->flag_entries))) ||
739 !(segment->stream_offset_entries = av_calloc(segment->nb_index_entries, sizeof(*segment->stream_offset_entries))))
740 return AVERROR(ENOMEM);
742 for (i = 0; i < segment->nb_index_entries; i++) {
743 segment->temporal_offset_entries[i] = avio_r8(pb);
744 avio_r8(pb); /* KeyFrameOffset */
745 segment->flag_entries[i] = avio_r8(pb);
746 segment->stream_offset_entries[i] = avio_rb64(pb);
747 avio_skip(pb, length - 11);
752 static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
754 MXFIndexTableSegment *segment = arg;
757 segment->edit_unit_byte_count = avio_rb32(pb);
758 av_dlog(NULL, "EditUnitByteCount %d\n", segment->edit_unit_byte_count);
761 segment->index_sid = avio_rb32(pb);
762 av_dlog(NULL, "IndexSID %d\n", segment->index_sid);
765 segment->body_sid = avio_rb32(pb);
766 av_dlog(NULL, "BodySID %d\n", segment->body_sid);
769 av_dlog(NULL, "IndexEntryArray found\n");
770 return mxf_read_index_entry_array(pb, segment);
772 segment->index_edit_rate.num = avio_rb32(pb);
773 segment->index_edit_rate.den = avio_rb32(pb);
774 av_dlog(NULL, "IndexEditRate %d/%d\n", segment->index_edit_rate.num,
775 segment->index_edit_rate.den);
778 segment->index_start_position = avio_rb64(pb);
779 av_dlog(NULL, "IndexStartPosition %"PRId64"\n", segment->index_start_position);
782 segment->index_duration = avio_rb64(pb);
783 av_dlog(NULL, "IndexDuration %"PRId64"\n", segment->index_duration);
789 static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor)
791 int code, value, ofs = 0;
792 char layout[16] = {0}; /* not for printing, may end up not terminated on purpose */
797 av_dlog(NULL, "pixel layout: code %#x\n", code);
800 layout[ofs++] = code;
801 layout[ofs++] = value;
803 break; /* don't read byte by byte on sneaky files filled with lots of non-zeroes */
804 } while (code != 0); /* SMPTE 377M E.2.46 */
806 ff_mxf_decode_pixel_layout(layout, &descriptor->pix_fmt);
809 static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
811 MXFDescriptor *descriptor = arg;
812 descriptor->pix_fmt = AV_PIX_FMT_NONE;
815 descriptor->sub_descriptors_count = avio_rb32(pb);
816 descriptor->sub_descriptors_refs = av_calloc(descriptor->sub_descriptors_count, sizeof(UID));
817 if (!descriptor->sub_descriptors_refs)
818 return AVERROR(ENOMEM);
819 avio_skip(pb, 4); /* useless size of objects, always 16 according to specs */
820 avio_read(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
823 avio_read(pb, descriptor->essence_container_ul, 16);
826 descriptor->linked_track_id = avio_rb32(pb);
828 case 0x3201: /* PictureEssenceCoding */
829 avio_read(pb, descriptor->essence_codec_ul, 16);
832 descriptor->width = avio_rb32(pb);
835 descriptor->height = avio_rb32(pb);
838 descriptor->frame_layout = avio_r8(pb);
841 descriptor->aspect_ratio.num = avio_rb32(pb);
842 descriptor->aspect_ratio.den = avio_rb32(pb);
845 descriptor->field_dominance = avio_r8(pb);
848 descriptor->component_depth = avio_rb32(pb);
851 descriptor->horiz_subsampling = avio_rb32(pb);
854 descriptor->vert_subsampling = avio_rb32(pb);
857 descriptor->sample_rate.num = avio_rb32(pb);
858 descriptor->sample_rate.den = avio_rb32(pb);
860 case 0x3D06: /* SoundEssenceCompression */
861 avio_read(pb, descriptor->essence_codec_ul, 16);
864 descriptor->channels = avio_rb32(pb);
867 descriptor->bits_per_sample = avio_rb32(pb);
870 mxf_read_pixel_layout(pb, descriptor);
873 /* Private uid used by SONY C0023S01.mxf */
874 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
875 if (descriptor->extradata)
876 av_log(NULL, AV_LOG_WARNING, "Duplicate sony_mpeg4_extradata\n");
877 av_free(descriptor->extradata);
878 descriptor->extradata_size = 0;
879 descriptor->extradata = av_malloc(size);
880 if (!descriptor->extradata)
881 return AVERROR(ENOMEM);
882 descriptor->extradata_size = size;
883 avio_read(pb, descriptor->extradata, size);
891 * Match an uid independently of the version byte and up to len common bytes
894 static int mxf_match_uid(const UID key, const UID uid, int len)
897 for (i = 0; i < len; i++) {
898 if (i != 7 && key[i] != uid[i])
904 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
906 while (uls->uid[0]) {
907 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
914 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
920 for (i = 0; i < mxf->metadata_sets_count; i++) {
921 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
922 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
923 return mxf->metadata_sets[i];
929 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
930 // video essence container uls
931 { { 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 */
932 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
933 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
934 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
937 /* EC ULs for intra-only formats */
938 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
939 { { 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 */
940 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
943 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
944 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
945 { { 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 */
946 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */
947 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
950 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
951 // sound essence container uls
952 { { 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 */
953 { { 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 */
954 { { 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 */
955 { { 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 */
956 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
959 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
961 int i, j, nb_segments = 0;
962 MXFIndexTableSegment **unsorted_segments;
963 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
965 /* count number of segments, allocate arrays and copy unsorted segments */
966 for (i = 0; i < mxf->metadata_sets_count; i++)
967 if (mxf->metadata_sets[i]->type == IndexTableSegment)
971 return AVERROR_INVALIDDATA;
973 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
974 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
975 av_freep(sorted_segments);
976 av_free(unsorted_segments);
977 return AVERROR(ENOMEM);
980 for (i = j = 0; i < mxf->metadata_sets_count; i++)
981 if (mxf->metadata_sets[i]->type == IndexTableSegment)
982 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
984 *nb_sorted_segments = 0;
986 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
987 for (i = 0; i < nb_segments; i++) {
988 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
989 uint64_t best_index_duration = 0;
991 for (j = 0; j < nb_segments; j++) {
992 MXFIndexTableSegment *s = unsorted_segments[j];
994 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
995 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
996 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
998 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
999 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
1000 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
1002 best_body_sid = s->body_sid;
1003 best_index_sid = s->index_sid;
1004 best_index_start = s->index_start_position;
1005 best_index_duration = s->index_duration;
1009 /* no suitable entry found -> we're done */
1013 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1014 last_body_sid = best_body_sid;
1015 last_index_sid = best_index_sid;
1016 last_index_start = best_index_start;
1019 av_free(unsorted_segments);
1025 * Computes the absolute file offset of the given essence container offset
1027 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1030 int64_t offset_in = offset; /* for logging */
1032 for (x = 0; x < mxf->partitions_count; x++) {
1033 MXFPartition *p = &mxf->partitions[x];
1035 if (p->body_sid != body_sid)
1038 if (offset < p->essence_length || !p->essence_length) {
1039 *offset_out = p->essence_offset + offset;
1043 offset -= p->essence_length;
1046 av_log(mxf->fc, AV_LOG_ERROR,
1047 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1048 offset_in, body_sid);
1050 return AVERROR_INVALIDDATA;
1054 * Returns the end position of the essence container with given BodySID, or zero if unknown
1056 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1061 for (x = 0; x < mxf->partitions_count; x++) {
1062 MXFPartition *p = &mxf->partitions[x];
1064 if (p->body_sid != body_sid)
1067 if (!p->essence_length)
1070 ret = p->essence_offset + p->essence_length;
1076 /* EditUnit -> absolute offset */
1077 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)
1080 int64_t offset_temp = 0;
1082 for (i = 0; i < index_table->nb_segments; i++) {
1083 MXFIndexTableSegment *s = index_table->segments[i];
1085 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1087 if (edit_unit < s->index_start_position + s->index_duration) {
1088 int64_t index = edit_unit - s->index_start_position;
1090 if (s->edit_unit_byte_count)
1091 offset_temp += s->edit_unit_byte_count * index;
1092 else if (s->nb_index_entries) {
1093 if (s->nb_index_entries == 2 * s->index_duration + 1)
1094 index *= 2; /* Avid index */
1096 if (index < 0 || index >= s->nb_index_entries) {
1097 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1098 index_table->index_sid, s->index_start_position);
1099 return AVERROR_INVALIDDATA;
1102 offset_temp = s->stream_offset_entries[index];
1104 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1105 index_table->index_sid, s->index_start_position);
1106 return AVERROR_INVALIDDATA;
1110 *edit_unit_out = edit_unit;
1112 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1114 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1115 offset_temp += s->edit_unit_byte_count * s->index_duration;
1120 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);
1122 return AVERROR_INVALIDDATA;
1125 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1128 int8_t max_temporal_offset = -128;
1130 /* first compute how many entries we have */
1131 for (i = 0; i < index_table->nb_segments; i++) {
1132 MXFIndexTableSegment *s = index_table->segments[i];
1134 if (!s->nb_index_entries) {
1135 index_table->nb_ptses = 0;
1136 return 0; /* no TemporalOffsets */
1139 index_table->nb_ptses += s->index_duration;
1142 /* paranoid check */
1143 if (index_table->nb_ptses <= 0)
1146 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1147 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1148 av_freep(&index_table->ptses);
1149 return AVERROR(ENOMEM);
1152 /* we may have a few bad TemporalOffsets
1153 * make sure the corresponding PTSes don't have the bogus value 0 */
1154 for (x = 0; x < index_table->nb_ptses; x++)
1155 index_table->ptses[x] = AV_NOPTS_VALUE;
1169 * We want to transform it into this:
1180 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1181 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1182 * The latter makes DTS <= PTS.
1184 for (i = x = 0; i < index_table->nb_segments; i++) {
1185 MXFIndexTableSegment *s = index_table->segments[i];
1186 int index_delta = 1;
1187 int n = s->nb_index_entries;
1189 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1190 index_delta = 2; /* Avid index */
1191 /* ignore the last entry - it's the size of the essence container */
1195 for (j = 0; j < n; j += index_delta, x++) {
1196 int offset = s->temporal_offset_entries[j] / index_delta;
1197 int index = x + offset;
1199 if (x >= index_table->nb_ptses) {
1200 av_log(mxf->fc, AV_LOG_ERROR,
1201 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1202 s->nb_index_entries, s->index_duration);
1206 index_table->fake_index[x].timestamp = x;
1207 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1209 if (index < 0 || index >= index_table->nb_ptses) {
1210 av_log(mxf->fc, AV_LOG_ERROR,
1211 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1216 index_table->ptses[index] = x;
1217 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1221 index_table->first_dts = -max_temporal_offset;
1227 * Sorts and collects index table segments into index tables.
1228 * Also computes PTSes if possible.
1230 static int mxf_compute_index_tables(MXFContext *mxf)
1232 int i, j, k, ret, nb_sorted_segments;
1233 MXFIndexTableSegment **sorted_segments = NULL;
1235 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1236 nb_sorted_segments <= 0) {
1237 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1241 /* sanity check and count unique BodySIDs/IndexSIDs */
1242 for (i = 0; i < nb_sorted_segments; i++) {
1243 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1244 mxf->nb_index_tables++;
1245 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1246 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1247 ret = AVERROR_INVALIDDATA;
1248 goto finish_decoding_index;
1252 mxf->index_tables = av_mallocz_array(mxf->nb_index_tables,
1253 sizeof(*mxf->index_tables));
1254 if (!mxf->index_tables) {
1255 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1256 ret = AVERROR(ENOMEM);
1257 goto finish_decoding_index;
1260 /* distribute sorted segments to index tables */
1261 for (i = j = 0; i < nb_sorted_segments; i++) {
1262 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1267 mxf->index_tables[j].nb_segments++;
1270 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1271 MXFIndexTable *t = &mxf->index_tables[j];
1273 t->segments = av_mallocz_array(t->nb_segments,
1274 sizeof(*t->segments));
1277 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment"
1278 " pointer array\n");
1279 ret = AVERROR(ENOMEM);
1280 goto finish_decoding_index;
1283 if (sorted_segments[i]->index_start_position)
1284 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1285 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1287 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1288 t->index_sid = sorted_segments[i]->index_sid;
1289 t->body_sid = sorted_segments[i]->body_sid;
1291 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1292 goto finish_decoding_index;
1294 /* fix zero IndexDurations */
1295 for (k = 0; k < t->nb_segments; k++) {
1296 if (t->segments[k]->index_duration)
1299 if (t->nb_segments > 1)
1300 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1303 if (mxf->fc->nb_streams <= 0) {
1304 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1308 /* assume the first stream's duration is reasonable
1309 * leave index_duration = 0 on further segments in case we have any (unlikely)
1311 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1317 finish_decoding_index:
1318 av_free(sorted_segments);
1322 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1324 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1325 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1326 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1327 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1330 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1332 char buf[AV_TIMECODE_STR_SIZE];
1333 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1338 static int mxf_parse_structural_metadata(MXFContext *mxf)
1340 MXFPackage *material_package = NULL;
1341 MXFPackage *temp_package = NULL;
1344 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1345 /* TODO: handle multiple material packages (OP3x) */
1346 for (i = 0; i < mxf->packages_count; i++) {
1347 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1348 if (material_package) break;
1350 if (!material_package) {
1351 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1352 return AVERROR_INVALIDDATA;
1355 for (i = 0; i < material_package->tracks_count; i++) {
1356 MXFPackage *source_package = NULL;
1357 MXFTrack *material_track = NULL;
1358 MXFTrack *source_track = NULL;
1359 MXFTrack *temp_track = NULL;
1360 MXFDescriptor *descriptor = NULL;
1361 MXFStructuralComponent *component = NULL;
1362 MXFTimecodeComponent *mxf_tc = NULL;
1363 UID *essence_container_ul = NULL;
1364 const MXFCodecUL *codec_ul = NULL;
1365 const MXFCodecUL *container_ul = NULL;
1366 const MXFCodecUL *pix_fmt_ul = NULL;
1371 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1372 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1376 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1377 mxf_tc = (MXFTimecodeComponent*)component;
1378 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1379 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1380 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1384 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1385 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1389 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1390 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], TimecodeComponent);
1394 mxf_tc = (MXFTimecodeComponent*)component;
1395 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1396 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1397 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1402 /* TODO: handle multiple source clips */
1403 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1404 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1408 for (k = 0; k < mxf->packages_count; k++) {
1409 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1412 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1413 source_package = temp_package;
1417 if (!source_package) {
1418 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1421 for (k = 0; k < source_package->tracks_count; k++) {
1422 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1423 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1424 ret = AVERROR_INVALIDDATA;
1427 if (temp_track->track_id == component->source_track_id) {
1428 source_track = temp_track;
1432 if (!source_track) {
1433 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1437 if (!source_track || !component)
1440 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1441 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1442 ret = AVERROR_INVALIDDATA;
1446 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1447 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1448 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1449 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1453 st = avformat_new_stream(mxf->fc, NULL);
1455 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1456 ret = AVERROR(ENOMEM);
1459 st->id = source_track->track_id;
1460 st->priv_data = source_track;
1461 source_track->original_duration = st->duration = component->duration;
1462 if (st->duration == -1)
1463 st->duration = AV_NOPTS_VALUE;
1464 st->start_time = component->start_position;
1465 if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1466 av_log(mxf->fc, AV_LOG_WARNING,
1467 "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1468 material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1469 material_track->edit_rate = (AVRational){25, 1};
1471 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1473 /* ensure SourceTrack EditRate == MaterialTrack EditRate since only the former is accessible via st->priv_data */
1474 source_track->edit_rate = material_track->edit_rate;
1476 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1477 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1478 st->codec->codec_type = codec_ul->id;
1480 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1481 if (source_package->descriptor) {
1482 if (source_package->descriptor->type == MultipleDescriptor) {
1483 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1484 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1486 if (!sub_descriptor) {
1487 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1490 if (sub_descriptor->linked_track_id == source_track->track_id) {
1491 descriptor = sub_descriptor;
1495 } else if (source_package->descriptor->type == Descriptor)
1496 descriptor = source_package->descriptor;
1499 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1502 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1503 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1504 essence_container_ul = &descriptor->essence_container_ul;
1505 /* HACK: replacing the original key with mxf_encrypted_essence_container
1506 * is not allowed according to s429-6, try to find correct information anyway */
1507 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1508 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1509 for (k = 0; k < mxf->metadata_sets_count; k++) {
1510 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1511 if (metadata->type == CryptoContext) {
1512 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1518 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1519 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1520 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1521 av_log(mxf->fc, AV_LOG_VERBOSE, "%s: Universal Label: ",
1522 avcodec_get_name(st->codec->codec_id));
1523 for (k = 0; k < 16; k++) {
1524 av_log(mxf->fc, AV_LOG_VERBOSE, "%.2x",
1525 descriptor->essence_codec_ul[k]);
1526 if (!(k+1 & 19) || k == 5)
1527 av_log(mxf->fc, AV_LOG_VERBOSE, ".");
1529 av_log(mxf->fc, AV_LOG_VERBOSE, "\n");
1531 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1532 source_track->intra_only = mxf_is_intra_only(descriptor);
1533 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1534 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1535 st->codec->codec_id = container_ul->id;
1536 st->codec->width = descriptor->width;
1537 st->codec->height = descriptor->height; /* Field height, not frame height */
1538 switch (descriptor->frame_layout) {
1539 case SegmentedFrame:
1540 /* This one is a weird layout I don't fully understand. */
1541 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1544 st->codec->field_order = AV_FIELD_PROGRESSIVE;
1547 /* Every other line is stored and needs to be duplicated. */
1548 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1549 break; /* The correct thing to do here is fall through, but by breaking we might be
1550 able to decode some streams at half the vertical resolution, rather than not al all.
1551 It's also for compatibility with the old behavior. */
1554 case SeparateFields:
1555 st->codec->height *= 2; /* Turn field height into frame height. */
1558 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1560 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1561 st->codec->pix_fmt = descriptor->pix_fmt;
1562 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1563 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1564 &descriptor->essence_codec_ul);
1565 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1566 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1567 /* support files created before RP224v10 by defaulting to UYVY422
1568 if subsampling is 4:2:2 and component depth is 8-bit */
1569 if (descriptor->horiz_subsampling == 2 &&
1570 descriptor->vert_subsampling == 1 &&
1571 descriptor->component_depth == 8) {
1572 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1577 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1578 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1579 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1580 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1581 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))
1582 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1583 st->codec->channels = descriptor->channels;
1584 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1586 if (descriptor->sample_rate.den > 0) {
1587 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1588 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1590 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) "
1591 "found for stream #%d, time base forced to 1/48000\n",
1592 descriptor->sample_rate.num, descriptor->sample_rate.den,
1594 avpriv_set_pts_info(st, 64, 1, 48000);
1597 /* if duration is set, rescale it from EditRate to SampleRate */
1598 if (st->duration != AV_NOPTS_VALUE)
1599 st->duration = av_rescale_q(st->duration, av_inv_q(material_track->edit_rate), st->time_base);
1601 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1602 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1603 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1604 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1605 else if (descriptor->bits_per_sample == 32)
1606 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1607 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1608 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1609 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1610 else if (descriptor->bits_per_sample == 32)
1611 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1612 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1613 st->need_parsing = AVSTREAM_PARSE_FULL;
1616 if (descriptor->extradata) {
1617 if (!ff_alloc_extradata(st->codec, descriptor->extradata_size)) {
1618 memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size);
1620 } else if (st->codec->codec_id == AV_CODEC_ID_H264) {
1621 ret = ff_generate_avci_extradata(st);
1625 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1626 /* TODO: decode timestamps */
1627 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1636 static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str)
1642 return AVERROR(EINVAL);
1644 buf_size = size + size/2 + 1;
1645 *str = av_malloc(buf_size);
1647 return AVERROR(ENOMEM);
1649 if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) {
1657 static int mxf_uid_to_str(UID uid, char **str)
1661 p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1);
1663 return AVERROR(ENOMEM);
1664 for (i = 0; i < sizeof(UID); i++) {
1665 snprintf(p, 2 + 1, "%.2x", uid[i]);
1667 if (i == 3 || i == 5 || i == 7 || i == 9) {
1668 snprintf(p, 1 + 1, "-");
1675 static int mxf_timestamp_to_str(uint64_t timestamp, char **str)
1677 struct tm time = {0};
1678 time.tm_year = (timestamp >> 48) - 1900;
1679 time.tm_mon = (timestamp >> 40 & 0xFF) - 1;
1680 time.tm_mday = (timestamp >> 32 & 0xFF);
1681 time.tm_hour = (timestamp >> 24 & 0xFF);
1682 time.tm_min = (timestamp >> 16 & 0xFF);
1683 time.tm_sec = (timestamp >> 8 & 0xFF);
1685 /* ensure month/day are valid */
1686 time.tm_mon = FFMAX(time.tm_mon, 0);
1687 time.tm_mday = FFMAX(time.tm_mday, 1);
1689 *str = av_mallocz(32);
1691 return AVERROR(ENOMEM);
1692 strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time);
1697 #define SET_STR_METADATA(pb, name, str) do { \
1698 if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \
1700 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1703 #define SET_UID_METADATA(pb, name, var, str) do { \
1704 avio_read(pb, var, 16); \
1705 if ((ret = mxf_uid_to_str(var, &str)) < 0) \
1707 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1710 #define SET_TS_METADATA(pb, name, var, str) do { \
1711 var = avio_rb64(pb); \
1712 if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \
1714 av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \
1717 static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset)
1719 MXFContext *mxf = arg;
1720 AVFormatContext *s = mxf->fc;
1727 SET_STR_METADATA(pb, "company_name", str);
1730 SET_STR_METADATA(pb, "product_name", str);
1733 SET_STR_METADATA(pb, "product_version", str);
1736 SET_UID_METADATA(pb, "product_uid", uid, str);
1739 SET_TS_METADATA(pb, "modification_date", ts, str);
1742 SET_STR_METADATA(pb, "application_platform", str);
1745 SET_UID_METADATA(pb, "generation_uid", uid, str);
1748 SET_UID_METADATA(pb, "uid", uid, str);
1754 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1755 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1756 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1757 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1758 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1759 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1760 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1761 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1762 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1763 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1764 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1765 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1766 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0D,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata },
1767 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1768 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1769 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1770 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1771 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1772 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1773 { { 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 */
1774 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1775 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1776 { { 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 */
1777 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1778 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1779 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1780 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1781 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1782 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1783 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1784 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1787 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1789 AVIOContext *pb = mxf->fc->pb;
1790 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1791 uint64_t klv_end = avio_tell(pb) + klv->length;
1794 return AVERROR(ENOMEM);
1795 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1797 int tag = avio_rb16(pb);
1798 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1799 uint64_t next = avio_tell(pb) + size;
1802 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1803 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1804 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1807 if (tag > 0x7FFF) { /* dynamic tag */
1809 for (i = 0; i < mxf->local_tags_count; i++) {
1810 int local_tag = AV_RB16(mxf->local_tags+i*18);
1811 if (local_tag == tag) {
1812 memcpy(uid, mxf->local_tags+i*18+2, 16);
1813 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1814 PRINT_KEY(mxf->fc, "uid", uid);
1818 if (ctx_size && tag == 0x3C0A)
1819 avio_read(pb, ctx->uid, 16);
1820 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1823 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1824 * it extending past the end of the KLV though (zzuf5.mxf). */
1825 if (avio_tell(pb) > klv_end) {
1829 av_log(mxf->fc, AV_LOG_ERROR,
1830 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1832 return AVERROR_INVALIDDATA;
1833 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1834 avio_seek(pb, next, SEEK_SET);
1836 if (ctx_size) ctx->type = type;
1837 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1841 * Seeks to the previous partition, if possible
1842 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1844 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1846 AVIOContext *pb = mxf->fc->pb;
1848 if (!mxf->current_partition ||
1849 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1850 return 0; /* we've parsed all partitions */
1852 /* seek to previous partition */
1853 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1854 mxf->current_partition = NULL;
1856 av_dlog(mxf->fc, "seeking to previous partition\n");
1862 * Called when essence is encountered
1863 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1865 static int mxf_parse_handle_essence(MXFContext *mxf)
1867 AVIOContext *pb = mxf->fc->pb;
1870 if (mxf->parsing_backward) {
1871 return mxf_seek_to_previous_partition(mxf);
1872 } else if (mxf->footer_partition || mxf->last_partition){
1875 offset = mxf->footer_partition ? mxf->footer_partition : mxf->last_partition;
1877 av_dlog(mxf->fc, "seeking to last partition\n");
1879 /* remember where we were so we don't end up seeking further back than this */
1880 mxf->last_forward_tell = avio_tell(pb);
1882 if (!pb->seekable) {
1883 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n");
1887 /* seek to last partition and parse backward */
1888 if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) {
1889 av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to last partition @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1890 mxf->run_in + offset, ret);
1894 mxf->current_partition = NULL;
1895 mxf->parsing_backward = 1;
1897 av_dlog(mxf->fc, "can't find last partition\n");
1905 * Called when the next partition or EOF is encountered
1906 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1908 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1910 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1914 * Figures out the proper offset and length of the essence container in each partition
1916 static void mxf_compute_essence_containers(MXFContext *mxf)
1920 /* everything is already correct */
1921 if (mxf->op == OPAtom)
1924 for (x = 0; x < mxf->partitions_count; x++) {
1925 MXFPartition *p = &mxf->partitions[x];
1928 continue; /* BodySID == 0 -> no essence */
1930 if (x >= mxf->partitions_count - 1)
1931 break; /* last partition - can't compute length (and we don't need to) */
1933 /* essence container spans to the next partition */
1934 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1936 if (p->essence_length < 0) {
1937 /* next ThisPartition < essence_offset */
1938 p->essence_length = 0;
1939 av_log(mxf->fc, AV_LOG_ERROR,
1940 "partition %i: bad ThisPartition = %"PRIX64"\n",
1941 x+1, mxf->partitions[x+1].this_partition);
1946 static int64_t round_to_kag(int64_t position, int kag_size)
1948 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1949 /* NOTE: kag_size may be any integer between 1 - 2^10 */
1950 int64_t ret = (position / kag_size) * kag_size;
1951 return ret == position ? ret : ret + kag_size;
1954 static int is_pcm(enum AVCodecID codec_id)
1956 /* we only care about "normal" PCM codecs until we get samples */
1957 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1961 * Deal with the case where for some audio atoms EditUnitByteCount is
1962 * very small (2, 4..). In those cases we should read more than one
1963 * sample per call to mxf_read_packet().
1965 static void mxf_handle_small_eubc(AVFormatContext *s)
1967 MXFContext *mxf = s->priv_data;
1969 /* assuming non-OPAtom == frame wrapped
1970 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1971 if (mxf->op != OPAtom)
1974 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1975 if (s->nb_streams != 1 ||
1976 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1977 !is_pcm(s->streams[0]->codec->codec_id) ||
1978 mxf->nb_index_tables != 1 ||
1979 mxf->index_tables[0].nb_segments != 1 ||
1980 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1983 /* arbitrarily default to 48 kHz PAL audio frame size */
1984 /* TODO: We could compute this from the ratio between the audio
1985 * and video edit rates for 48 kHz NTSC we could use the
1986 * 1802-1802-1802-1802-1801 pattern. */
1987 mxf->edit_units_per_packet = 1920;
1990 static void mxf_read_random_index_pack(AVFormatContext *s)
1992 MXFContext *mxf = s->priv_data;
1997 if (!s->pb->seekable)
2000 file_size = avio_size(s->pb);
2001 avio_seek(s->pb, file_size - 4, SEEK_SET);
2002 length = avio_rb32(s->pb);
2003 if (length <= 32 || length >= FFMIN(file_size, INT_MAX))
2005 avio_seek(s->pb, file_size - length, SEEK_SET);
2006 if (klv_read_packet(&klv, s->pb) < 0 ||
2007 !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) ||
2008 klv.length != length - 20)
2011 avio_skip(s->pb, klv.length - 12);
2012 mxf->last_partition = avio_rb64(s->pb);
2015 avio_seek(s->pb, mxf->run_in, SEEK_SET);
2018 static int mxf_read_header(AVFormatContext *s)
2020 MXFContext *mxf = s->priv_data;
2022 int64_t essence_offset = 0;
2023 int64_t last_pos = -1;
2024 uint64_t last_pos_index = 1;
2027 mxf->last_forward_tell = INT64_MAX;
2028 mxf->edit_units_per_packet = 1;
2030 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
2031 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
2032 return AVERROR_INVALIDDATA;
2034 avio_seek(s->pb, -14, SEEK_CUR);
2036 mxf->run_in = avio_tell(s->pb);
2038 mxf_read_random_index_pack(s);
2040 while (!url_feof(s->pb)) {
2041 const MXFMetadataReadTableEntry *metadata;
2042 if (avio_tell(s->pb) == last_pos) {
2043 av_log(mxf->fc, AV_LOG_ERROR, "MXF structure loop detected\n");
2044 return AVERROR_INVALIDDATA;
2046 if ((1ULL<<61) % last_pos_index++ == 0)
2047 last_pos = avio_tell(s->pb);
2048 if (klv_read_packet(&klv, s->pb) < 0) {
2049 /* EOF - seek to previous partition or stop */
2050 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2056 PRINT_KEY(s, "read header", klv.key);
2057 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2058 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
2059 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2060 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
2061 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
2063 if (!mxf->current_partition) {
2064 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
2065 return AVERROR_INVALIDDATA;
2068 if (!mxf->current_partition->essence_offset) {
2069 /* for OP1a we compute essence_offset
2070 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
2071 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
2072 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
2074 int64_t op1a_essence_offset =
2075 round_to_kag(mxf->current_partition->this_partition +
2076 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
2077 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
2078 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
2080 if (mxf->op == OPAtom) {
2081 /* point essence_offset to the actual data
2082 * OPAtom has all the essence in one big KLV
2084 mxf->current_partition->essence_offset = avio_tell(s->pb);
2085 mxf->current_partition->essence_length = klv.length;
2087 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
2088 mxf->current_partition->essence_offset = op1a_essence_offset;
2092 if (!essence_offset)
2093 essence_offset = klv.offset;
2095 /* seek to footer, previous partition or stop */
2096 if (mxf_parse_handle_essence(mxf) <= 0)
2099 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
2100 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
2101 /* next partition pack - keep going, seek to previous partition or stop */
2102 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
2104 else if (mxf->parsing_backward)
2106 /* we're still parsing forward. proceed to parsing this partition pack */
2109 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
2110 if (IS_KLV_KEY(klv.key, metadata->key)) {
2112 if (klv.key[5] == 0x53) {
2113 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
2115 uint64_t next = avio_tell(s->pb) + klv.length;
2116 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
2118 /* only seek forward, else this can loop for a long time */
2119 if (avio_tell(s->pb) > next) {
2120 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
2122 return AVERROR_INVALIDDATA;
2125 avio_seek(s->pb, next, SEEK_SET);
2128 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
2134 if (!metadata->read)
2135 avio_skip(s->pb, klv.length);
2137 /* FIXME avoid seek */
2138 if (!essence_offset) {
2139 av_log(s, AV_LOG_ERROR, "no essence\n");
2140 return AVERROR_INVALIDDATA;
2142 avio_seek(s->pb, essence_offset, SEEK_SET);
2144 mxf_compute_essence_containers(mxf);
2146 /* we need to do this before computing the index tables
2147 * to be able to fill in zero IndexDurations with st->duration */
2148 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
2151 if ((ret = mxf_compute_index_tables(mxf)) < 0)
2154 if (mxf->nb_index_tables > 1) {
2155 /* TODO: look up which IndexSID to use via EssenceContainerData */
2156 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
2157 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
2158 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
2159 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
2160 ret = AVERROR_INVALIDDATA;
2164 mxf_handle_small_eubc(s);
2174 * Sets mxf->current_edit_unit based on what offset we're currently at.
2175 * @return next_ofs if OK, <0 on error
2177 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
2179 int64_t last_ofs = -1, next_ofs = -1;
2180 MXFIndexTable *t = &mxf->index_tables[0];
2182 /* this is called from the OP1a demuxing logic, which means there
2183 * may be no index tables */
2184 if (mxf->nb_index_tables <= 0)
2187 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
2188 while (mxf->current_edit_unit >= 0) {
2189 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
2192 if (next_ofs <= last_ofs) {
2193 /* large next_ofs didn't change or current_edit_unit wrapped
2194 * around this fixes the infinite loop on zzuf3.mxf */
2195 av_log(mxf->fc, AV_LOG_ERROR,
2196 "next_ofs didn't change. not deriving packet timestamps\n");
2200 if (next_ofs > current_offset)
2203 last_ofs = next_ofs;
2204 mxf->current_edit_unit++;
2207 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2208 if (mxf->current_edit_unit < 0)
2214 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2216 int i, total = 0, size = 0;
2217 AVStream *st = mxf->fc->streams[stream_index];
2218 MXFTrack *track = st->priv_data;
2219 AVRational time_base = av_inv_q(track->edit_rate);
2220 AVRational sample_rate = av_inv_q(st->time_base);
2221 const MXFSamplesPerFrame *spf = NULL;
2223 if ((sample_rate.num / sample_rate.den) == 48000)
2224 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2226 int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2227 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2228 av_mul_q(sample_rate, time_base)));
2230 av_log(mxf->fc, AV_LOG_WARNING,
2231 "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2232 stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2236 while (spf->samples_per_frame[size]) {
2237 total += spf->samples_per_frame[size];
2243 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2244 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2245 *sample_count += spf->samples_per_frame[i];
2251 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2253 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2254 pkt->pts = track->sample_count;
2255 if ( codec->channels <= 0
2256 || av_get_bits_per_sample(codec->codec_id) <= 0
2257 || codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) < 8)
2258 return AVERROR(EINVAL);
2259 track->sample_count += pkt->size / (codec->channels * (int64_t)av_get_bits_per_sample(codec->codec_id) / 8);
2263 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2266 MXFContext *mxf = s->priv_data;
2268 while (klv_read_packet(&klv, s->pb) == 0) {
2270 PRINT_KEY(s, "read packet", klv.key);
2271 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2272 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2273 ret = mxf_decrypt_triplet(s, pkt, &klv);
2275 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2276 return AVERROR_INVALIDDATA;
2280 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2281 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2282 int index = mxf_get_stream_index(s, &klv);
2283 int64_t next_ofs, next_klv;
2286 AVCodecContext *codec;
2289 av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2293 st = s->streams[index];
2294 track = st->priv_data;
2296 if (s->streams[index]->discard == AVDISCARD_ALL)
2299 next_klv = avio_tell(s->pb) + klv.length;
2300 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2302 if (next_ofs >= 0 && next_klv > next_ofs) {
2303 /* if this check is hit then it's possible OPAtom was treated as OP1a
2304 * truncate the packet since it's probably very large (>2 GiB is common) */
2305 avpriv_request_sample(s,
2306 "OPAtom misinterpreted as OP1a?"
2307 "KLV for edit unit %i extending into "
2309 mxf->current_edit_unit);
2310 klv.length = next_ofs - avio_tell(s->pb);
2313 /* check for 8 channels AES3 element */
2314 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2315 if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2316 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2317 return AVERROR_INVALIDDATA;
2320 ret = av_get_packet(s->pb, pkt, klv.length);
2324 pkt->stream_index = index;
2325 pkt->pos = klv.offset;
2327 codec = s->streams[index]->codec;
2328 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2329 /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2330 MXFIndexTable *t = &mxf->index_tables[0];
2332 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2333 pkt->dts = mxf->current_edit_unit + t->first_dts;
2334 pkt->pts = t->ptses[mxf->current_edit_unit];
2335 } else if (track->intra_only) {
2336 /* intra-only -> PTS = EditUnit.
2337 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2338 pkt->pts = mxf->current_edit_unit;
2340 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2341 int ret = mxf_set_audio_pts(mxf, codec, pkt);
2346 /* seek for truncated packets */
2347 avio_seek(s->pb, next_klv, SEEK_SET);
2352 avio_skip(s->pb, klv.length);
2354 return url_feof(s->pb) ? AVERROR_EOF : -1;
2357 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2359 MXFContext *mxf = s->priv_data;
2361 int64_t ret64, pos, next_pos;
2366 if (mxf->op != OPAtom)
2367 return mxf_read_packet_old(s, pkt);
2369 /* OPAtom - clip wrapped demuxing */
2370 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2372 t = &mxf->index_tables[0];
2374 if (mxf->current_edit_unit >= st->duration)
2377 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2379 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2382 /* compute size by finding the next edit unit or the end of the essence container
2383 * not pretty, but it works */
2384 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2385 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2386 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2387 return AVERROR_INVALIDDATA;
2390 if ((size = next_pos - pos) <= 0) {
2391 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2392 return AVERROR_INVALIDDATA;
2395 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2398 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2401 pkt->stream_index = 0;
2403 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2404 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2405 pkt->dts = mxf->current_edit_unit + t->first_dts;
2406 pkt->pts = t->ptses[mxf->current_edit_unit];
2407 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2408 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2413 mxf->current_edit_unit += edit_units;
2418 static int mxf_read_close(AVFormatContext *s)
2420 MXFContext *mxf = s->priv_data;
2421 MXFIndexTableSegment *seg;
2424 av_freep(&mxf->packages_refs);
2426 for (i = 0; i < s->nb_streams; i++)
2427 s->streams[i]->priv_data = NULL;
2429 for (i = 0; i < mxf->metadata_sets_count; i++) {
2430 switch (mxf->metadata_sets[i]->type) {
2432 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata);
2434 case MultipleDescriptor:
2435 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2438 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2441 case MaterialPackage:
2442 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2444 case IndexTableSegment:
2445 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2446 av_freep(&seg->temporal_offset_entries);
2447 av_freep(&seg->flag_entries);
2448 av_freep(&seg->stream_offset_entries);
2453 av_freep(&mxf->metadata_sets[i]);
2455 av_freep(&mxf->partitions);
2456 av_freep(&mxf->metadata_sets);
2457 av_freep(&mxf->aesc);
2458 av_freep(&mxf->local_tags);
2460 if (mxf->index_tables) {
2461 for (i = 0; i < mxf->nb_index_tables; i++) {
2462 av_freep(&mxf->index_tables[i].segments);
2463 av_freep(&mxf->index_tables[i].ptses);
2464 av_freep(&mxf->index_tables[i].fake_index);
2467 av_freep(&mxf->index_tables);
2472 static int mxf_probe(AVProbeData *p) {
2473 const uint8_t *bufp = p->buf;
2474 const uint8_t *end = p->buf + p->buf_size;
2476 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2479 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2480 end -= sizeof(mxf_header_partition_pack_key);
2482 for (; bufp < end;) {
2483 if (!((bufp[13] - 1) & 0xF2)){
2484 if (AV_RN32(bufp ) == AV_RN32(mxf_header_partition_pack_key ) &&
2485 AV_RN32(bufp+ 4) == AV_RN32(mxf_header_partition_pack_key+ 4) &&
2486 AV_RN32(bufp+ 8) == AV_RN32(mxf_header_partition_pack_key+ 8) &&
2487 AV_RN16(bufp+12) == AV_RN16(mxf_header_partition_pack_key+12))
2488 return AVPROBE_SCORE_MAX;
2497 /* rudimentary byte seek */
2498 /* XXX: use MXF Index */
2499 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2501 AVStream *st = s->streams[stream_index];
2503 MXFContext* mxf = s->priv_data;
2507 MXFTrack *source_track = st->priv_data;
2509 /* if audio then truncate sample_time to EditRate */
2510 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2511 sample_time = av_rescale_q(sample_time, st->time_base, av_inv_q(source_track->edit_rate));
2513 if (mxf->nb_index_tables <= 0) {
2515 return AVERROR_INVALIDDATA;
2516 if (sample_time < 0)
2518 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2520 seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET);
2524 ff_update_cur_dts(s, st, sample_time);
2525 mxf->current_edit_unit = sample_time;
2527 t = &mxf->index_tables[0];
2529 /* clamp above zero, else ff_index_search_timestamp() returns negative
2530 * this also means we allow seeking before the start */
2531 sample_time = FFMAX(sample_time, 0);
2533 if (t->fake_index) {
2534 /* behave as if we have a proper index */
2535 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2538 /* no IndexEntryArray (one or more CBR segments)
2539 * make sure we don't seek past the end */
2540 sample_time = FFMIN(sample_time, source_track->original_duration - 1);
2543 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) < 0)
2546 ff_update_cur_dts(s, st, sample_time);
2547 mxf->current_edit_unit = sample_time;
2548 avio_seek(s->pb, seekpos, SEEK_SET);
2551 // Update all tracks sample count
2552 for (i = 0; i < s->nb_streams; i++) {
2553 AVStream *cur_st = s->streams[i];
2554 MXFTrack *cur_track = cur_st->priv_data;
2555 uint64_t current_sample_count = 0;
2556 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2557 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2561 cur_track->sample_count = current_sample_count;
2567 AVInputFormat ff_mxf_demuxer = {
2569 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2570 .priv_data_size = sizeof(MXFContext),
2571 .read_probe = mxf_probe,
2572 .read_header = mxf_read_header,
2573 .read_packet = mxf_read_packet,
2574 .read_close = mxf_read_close,
2575 .read_seek = mxf_read_seek,