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/timecode.h"
74 OPSONYOpt, /* FATE sample, violates the spec in places */
80 MXFPartitionType type;
81 uint64_t previous_partition;
84 int64_t this_partition;
85 int64_t essence_offset; ///< absolute offset of essence
86 int64_t essence_length;
88 int64_t header_byte_count;
89 int64_t index_byte_count;
95 enum MXFMetadataSetType type;
96 UID source_container_ul;
101 enum MXFMetadataSetType type;
102 UID source_package_uid;
103 UID data_definition_ul;
105 int64_t start_position;
107 } MXFStructuralComponent;
111 enum MXFMetadataSetType type;
112 UID data_definition_ul;
113 UID *structural_components_refs;
114 int structural_components_count;
120 enum MXFMetadataSetType type;
123 struct AVRational rate;
125 } MXFTimecodeComponent;
129 enum MXFMetadataSetType type;
130 MXFSequence *sequence; /* mandatory, and only one */
133 uint8_t track_number[4];
134 AVRational edit_rate;
136 uint64_t sample_count;
141 enum MXFMetadataSetType type;
142 UID essence_container_ul;
143 UID essence_codec_ul;
144 AVRational sample_rate;
145 AVRational aspect_ratio;
147 int height; /* Field height, not frame height */
148 int frame_layout; /* See MXFFrameLayout enum */
151 unsigned int component_depth;
152 unsigned int horiz_subsampling;
153 unsigned int vert_subsampling;
154 UID *sub_descriptors_refs;
155 int sub_descriptors_count;
159 enum AVPixelFormat pix_fmt;
164 enum MXFMetadataSetType type;
165 int edit_unit_byte_count;
168 AVRational index_edit_rate;
169 uint64_t index_start_position;
170 uint64_t index_duration;
171 int8_t *temporal_offset_entries;
173 uint64_t *stream_offset_entries;
174 int nb_index_entries;
175 } MXFIndexTableSegment;
179 enum MXFMetadataSetType type;
183 MXFDescriptor *descriptor; /* only one */
189 enum MXFMetadataSetType type;
192 /* decoded index table */
196 int nb_ptses; /* number of PTSes or total duration of index */
197 int64_t first_dts; /* DTS = EditUnit + first_dts */
198 int64_t *ptses; /* maps EditUnit -> PTS */
200 MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */
201 AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */
205 MXFPartition *partitions;
206 unsigned partitions_count;
210 MXFMetadataSet **metadata_sets;
211 int metadata_sets_count;
215 int local_tags_count;
216 uint64_t footer_partition;
217 KLVPacket current_klv_data;
218 int current_klv_index;
220 MXFPartition *current_partition;
221 int parsing_backward;
222 int64_t last_forward_tell;
223 int last_forward_partition;
224 int current_edit_unit;
226 MXFIndexTable *index_tables;
227 int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom)
230 enum MXFWrappingScheme {
235 /* NOTE: klv_offset is not set (-1) for local keys */
236 typedef int MXFMetadataReadFunc(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset);
240 MXFMetadataReadFunc *read;
242 enum MXFMetadataSetType type;
243 } MXFMetadataReadTableEntry;
245 static int mxf_read_close(AVFormatContext *s);
247 /* partial keys to match */
248 static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 };
249 static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 };
250 static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 };
251 static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 };
252 static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 };
253 /* complete keys to match */
254 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 };
255 static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 };
256 static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 };
257 static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 };
259 #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y)))
261 static int64_t klv_decode_ber_length(AVIOContext *pb)
263 uint64_t size = avio_r8(pb);
264 if (size & 0x80) { /* long form */
265 int bytes_num = size & 0x7f;
266 /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
268 return AVERROR_INVALIDDATA;
271 size = size << 8 | avio_r8(pb);
276 static int mxf_read_sync(AVIOContext *pb, const uint8_t *key, unsigned size)
279 for (i = 0; i < size && !url_feof(pb); i++) {
283 else if (b != key[i])
289 static int klv_read_packet(KLVPacket *klv, AVIOContext *pb)
291 if (!mxf_read_sync(pb, mxf_klv_key, 4))
292 return AVERROR_INVALIDDATA;
293 klv->offset = avio_tell(pb) - 4;
294 memcpy(klv->key, mxf_klv_key, 4);
295 avio_read(pb, klv->key + 4, 12);
296 klv->length = klv_decode_ber_length(pb);
297 return klv->length == -1 ? -1 : 0;
300 static int mxf_get_stream_index(AVFormatContext *s, KLVPacket *klv)
304 for (i = 0; i < s->nb_streams; i++) {
305 MXFTrack *track = s->streams[i]->priv_data;
307 if (!memcmp(klv->key + sizeof(mxf_essence_element_key), track->track_number, sizeof(track->track_number)))
310 /* return 0 if only one stream, for OP Atom files with 0 as track number */
311 return s->nb_streams == 1 ? 0 : -1;
314 /* XXX: use AVBitStreamFilter */
315 static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, int64_t length)
317 const uint8_t *buf_ptr, *end_ptr;
321 if (length > 61444) /* worst case PAL 1920 samples 8 channels */
322 return AVERROR_INVALIDDATA;
323 length = av_get_packet(pb, pkt, length);
326 data_ptr = pkt->data;
327 end_ptr = pkt->data + length;
328 buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */
329 for (; buf_ptr + st->codec->channels*4 <= end_ptr; ) {
330 for (i = 0; i < st->codec->channels; i++) {
331 uint32_t sample = bytestream_get_le32(&buf_ptr);
332 if (st->codec->bits_per_coded_sample == 24)
333 bytestream_put_le24(&data_ptr, (sample >> 4) & 0xffffff);
335 bytestream_put_le16(&data_ptr, (sample >> 12) & 0xffff);
337 buf_ptr += 32 - st->codec->channels*4; // always 8 channels stored SMPTE 331M
339 av_shrink_packet(pkt, data_ptr - pkt->data);
343 static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv)
345 static const uint8_t checkv[16] = {0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b, 0x43, 0x48, 0x55, 0x4b};
346 MXFContext *mxf = s->priv_data;
347 AVIOContext *pb = s->pb;
348 int64_t end = avio_tell(pb) + klv->length;
351 uint64_t plaintext_size;
356 if (!mxf->aesc && s->key && s->keylen == 16) {
357 mxf->aesc = av_aes_alloc();
359 return AVERROR(ENOMEM);
360 av_aes_init(mxf->aesc, s->key, 128, 1);
363 avio_skip(pb, klv_decode_ber_length(pb));
365 klv_decode_ber_length(pb);
366 plaintext_size = avio_rb64(pb);
368 klv_decode_ber_length(pb);
369 avio_read(pb, klv->key, 16);
370 if (!IS_KLV_KEY(klv, mxf_essence_element_key))
371 return AVERROR_INVALIDDATA;
372 index = mxf_get_stream_index(s, klv);
374 return AVERROR_INVALIDDATA;
376 klv_decode_ber_length(pb);
377 orig_size = avio_rb64(pb);
378 if (orig_size < plaintext_size)
379 return AVERROR_INVALIDDATA;
381 size = klv_decode_ber_length(pb);
382 if (size < 32 || size - 32 < orig_size)
383 return AVERROR_INVALIDDATA;
384 avio_read(pb, ivec, 16);
385 avio_read(pb, tmpbuf, 16);
387 av_aes_crypt(mxf->aesc, tmpbuf, tmpbuf, 1, ivec, 1);
388 if (memcmp(tmpbuf, checkv, 16))
389 av_log(s, AV_LOG_ERROR, "probably incorrect decryption key\n");
391 size = av_get_packet(pb, pkt, size);
394 else if (size < plaintext_size)
395 return AVERROR_INVALIDDATA;
396 size -= plaintext_size;
398 av_aes_crypt(mxf->aesc, &pkt->data[plaintext_size],
399 &pkt->data[plaintext_size], size >> 4, ivec, 1);
400 av_shrink_packet(pkt, orig_size);
401 pkt->stream_index = index;
402 avio_skip(pb, end - avio_tell(pb));
406 static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
408 MXFContext *mxf = arg;
409 int item_num = avio_rb32(pb);
410 int item_len = avio_rb32(pb);
412 if (item_len != 18) {
413 av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n",
415 return AVERROR_PATCHWELCOME;
417 if (item_num > 65536) {
418 av_log(mxf->fc, AV_LOG_ERROR, "item_num %d is too large\n", item_num);
419 return AVERROR_INVALIDDATA;
421 mxf->local_tags = av_calloc(item_num, item_len);
422 if (!mxf->local_tags)
423 return AVERROR(ENOMEM);
424 mxf->local_tags_count = item_num;
425 avio_read(pb, mxf->local_tags, item_num*item_len);
429 static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset)
431 MXFContext *mxf = arg;
432 MXFPartition *partition, *tmp_part;
434 uint64_t footer_partition;
435 uint32_t nb_essence_containers;
437 if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions))
438 return AVERROR(ENOMEM);
440 tmp_part = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions));
442 return AVERROR(ENOMEM);
443 mxf->partitions = tmp_part;
445 if (mxf->parsing_backward) {
446 /* insert the new partition pack in the middle
447 * this makes the entries in mxf->partitions sorted by offset */
448 memmove(&mxf->partitions[mxf->last_forward_partition+1],
449 &mxf->partitions[mxf->last_forward_partition],
450 (mxf->partitions_count - mxf->last_forward_partition)*sizeof(*mxf->partitions));
451 partition = mxf->current_partition = &mxf->partitions[mxf->last_forward_partition];
453 mxf->last_forward_partition++;
454 partition = mxf->current_partition = &mxf->partitions[mxf->partitions_count];
457 memset(partition, 0, sizeof(*partition));
458 mxf->partitions_count++;
459 partition->pack_length = avio_tell(pb) - klv_offset + size;
463 partition->type = Header;
466 partition->type = BodyPartition;
469 partition->type = Footer;
472 av_log(mxf->fc, AV_LOG_ERROR, "unknown partition type %i\n", uid[13]);
473 return AVERROR_INVALIDDATA;
476 /* consider both footers to be closed (there is only Footer and CompleteFooter) */
477 partition->closed = partition->type == Footer || !(uid[14] & 1);
478 partition->complete = uid[14] > 2;
480 partition->kag_size = avio_rb32(pb);
481 partition->this_partition = avio_rb64(pb);
482 partition->previous_partition = avio_rb64(pb);
483 footer_partition = avio_rb64(pb);
484 partition->header_byte_count = avio_rb64(pb);
485 partition->index_byte_count = avio_rb64(pb);
486 partition->index_sid = avio_rb32(pb);
488 partition->body_sid = avio_rb32(pb);
489 avio_read(pb, op, sizeof(UID));
490 nb_essence_containers = avio_rb32(pb);
492 /* some files don'thave FooterPartition set in every partition */
493 if (footer_partition) {
494 if (mxf->footer_partition && mxf->footer_partition != footer_partition) {
495 av_log(mxf->fc, AV_LOG_ERROR,
496 "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n",
497 mxf->footer_partition, footer_partition);
499 mxf->footer_partition = footer_partition;
504 "PartitionPack: ThisPartition = 0x%"PRIX64
505 ", PreviousPartition = 0x%"PRIX64", "
506 "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n",
507 partition->this_partition,
508 partition->previous_partition, footer_partition,
509 partition->index_sid, partition->body_sid);
511 /* sanity check PreviousPartition if set */
512 if (partition->previous_partition &&
513 mxf->run_in + partition->previous_partition >= klv_offset) {
514 av_log(mxf->fc, AV_LOG_ERROR,
515 "PreviousPartition points to this partition or forward\n");
516 return AVERROR_INVALIDDATA;
519 if (op[12] == 1 && op[13] == 1) mxf->op = OP1a;
520 else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b;
521 else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c;
522 else if (op[12] == 2 && op[13] == 1) mxf->op = OP2a;
523 else if (op[12] == 2 && op[13] == 2) mxf->op = OP2b;
524 else if (op[12] == 2 && op[13] == 3) mxf->op = OP2c;
525 else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a;
526 else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b;
527 else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c;
528 else if (op[12] == 64&& op[13] == 1) mxf->op = OPSONYOpt;
529 else if (op[12] == 0x10) {
530 /* SMPTE 390m: "There shall be exactly one essence container"
531 * The following block deals with files that violate this, namely:
532 * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a
533 * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */
534 if (nb_essence_containers != 1) {
535 MXFOP op = nb_essence_containers ? OP1a : OPAtom;
539 av_log(mxf->fc, AV_LOG_WARNING, "\"OPAtom\" with %u ECs - assuming %s\n",
540 nb_essence_containers, op == OP1a ? "OP1a" : "OPAtom");
546 av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]);
550 if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) {
551 av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size);
553 if (mxf->op == OPSONYOpt)
554 partition->kag_size = 512;
556 partition->kag_size = 1;
558 av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size);
564 static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set)
566 MXFMetadataSet **tmp;
567 if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets))
568 return AVERROR(ENOMEM);
569 tmp = av_realloc(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->component_depth = avio_rb32(pb);
845 descriptor->horiz_subsampling = avio_rb32(pb);
848 descriptor->vert_subsampling = avio_rb32(pb);
851 descriptor->sample_rate.num = avio_rb32(pb);
852 descriptor->sample_rate.den = avio_rb32(pb);
854 case 0x3D06: /* SoundEssenceCompression */
855 avio_read(pb, descriptor->essence_codec_ul, 16);
858 descriptor->channels = avio_rb32(pb);
861 descriptor->bits_per_sample = avio_rb32(pb);
864 mxf_read_pixel_layout(pb, descriptor);
867 /* Private uid used by SONY C0023S01.mxf */
868 if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
869 descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
870 if (!descriptor->extradata)
871 return AVERROR(ENOMEM);
872 descriptor->extradata_size = size;
873 avio_read(pb, descriptor->extradata, size);
881 * Match an uid independently of the version byte and up to len common bytes
884 static int mxf_match_uid(const UID key, const UID uid, int len)
887 for (i = 0; i < len; i++) {
888 if (i != 7 && key[i] != uid[i])
894 static const MXFCodecUL *mxf_get_codec_ul(const MXFCodecUL *uls, UID *uid)
896 while (uls->uid[0]) {
897 if(mxf_match_uid(uls->uid, *uid, uls->matching_len))
904 static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMetadataSetType type)
910 for (i = 0; i < mxf->metadata_sets_count; i++) {
911 if (!memcmp(*strong_ref, mxf->metadata_sets[i]->uid, 16) &&
912 (type == AnyType || mxf->metadata_sets[i]->type == type)) {
913 return mxf->metadata_sets[i];
919 static const MXFCodecUL mxf_picture_essence_container_uls[] = {
920 // video essence container uls
921 { { 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 */
922 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */
923 { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */
924 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
927 /* EC ULs for intra-only formats */
928 static const MXFCodecUL mxf_intra_only_essence_container_uls[] = {
929 { { 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 */
930 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
933 /* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */
934 static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = {
935 { { 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 */
936 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
939 static const MXFCodecUL mxf_sound_essence_container_uls[] = {
940 // sound essence container uls
941 { { 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 */
942 { { 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 */
943 { { 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 */
944 { { 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 */
945 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE },
948 static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments)
950 int i, j, nb_segments = 0;
951 MXFIndexTableSegment **unsorted_segments;
952 int last_body_sid = -1, last_index_sid = -1, last_index_start = -1;
954 /* count number of segments, allocate arrays and copy unsorted segments */
955 for (i = 0; i < mxf->metadata_sets_count; i++)
956 if (mxf->metadata_sets[i]->type == IndexTableSegment)
960 return AVERROR_INVALIDDATA;
962 if (!(unsorted_segments = av_calloc(nb_segments, sizeof(*unsorted_segments))) ||
963 !(*sorted_segments = av_calloc(nb_segments, sizeof(**sorted_segments)))) {
964 av_freep(sorted_segments);
965 av_free(unsorted_segments);
966 return AVERROR(ENOMEM);
969 for (i = j = 0; i < mxf->metadata_sets_count; i++)
970 if (mxf->metadata_sets[i]->type == IndexTableSegment)
971 unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
973 *nb_sorted_segments = 0;
975 /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */
976 for (i = 0; i < nb_segments; i++) {
977 int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1;
978 uint64_t best_index_duration = 0;
980 for (j = 0; j < nb_segments; j++) {
981 MXFIndexTableSegment *s = unsorted_segments[j];
983 /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates.
984 * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around.
985 * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have.
987 if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) &&
988 (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start ||
989 (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) {
991 best_body_sid = s->body_sid;
992 best_index_sid = s->index_sid;
993 best_index_start = s->index_start_position;
994 best_index_duration = s->index_duration;
998 /* no suitable entry found -> we're done */
1002 (*sorted_segments)[(*nb_sorted_segments)++] = unsorted_segments[best];
1003 last_body_sid = best_body_sid;
1004 last_index_sid = best_index_sid;
1005 last_index_start = best_index_start;
1008 av_free(unsorted_segments);
1014 * Computes the absolute file offset of the given essence container offset
1016 static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
1019 int64_t offset_in = offset; /* for logging */
1021 for (x = 0; x < mxf->partitions_count; x++) {
1022 MXFPartition *p = &mxf->partitions[x];
1024 if (p->body_sid != body_sid)
1027 if (offset < p->essence_length || !p->essence_length) {
1028 *offset_out = p->essence_offset + offset;
1032 offset -= p->essence_length;
1035 av_log(mxf->fc, AV_LOG_ERROR,
1036 "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n",
1037 offset_in, body_sid);
1039 return AVERROR_INVALIDDATA;
1043 * Returns the end position of the essence container with given BodySID, or zero if unknown
1045 static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid)
1050 for (x = 0; x < mxf->partitions_count; x++) {
1051 MXFPartition *p = &mxf->partitions[x];
1053 if (p->body_sid != body_sid)
1056 if (!p->essence_length)
1059 ret = p->essence_offset + p->essence_length;
1065 /* EditUnit -> absolute offset */
1066 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)
1069 int64_t offset_temp = 0;
1071 for (i = 0; i < index_table->nb_segments; i++) {
1072 MXFIndexTableSegment *s = index_table->segments[i];
1074 edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */
1076 if (edit_unit < s->index_start_position + s->index_duration) {
1077 int64_t index = edit_unit - s->index_start_position;
1079 if (s->edit_unit_byte_count)
1080 offset_temp += s->edit_unit_byte_count * index;
1081 else if (s->nb_index_entries) {
1082 if (s->nb_index_entries == 2 * s->index_duration + 1)
1083 index *= 2; /* Avid index */
1085 if (index < 0 || index >= s->nb_index_entries) {
1086 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n",
1087 index_table->index_sid, s->index_start_position);
1088 return AVERROR_INVALIDDATA;
1091 offset_temp = s->stream_offset_entries[index];
1093 av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
1094 index_table->index_sid, s->index_start_position);
1095 return AVERROR_INVALIDDATA;
1099 *edit_unit_out = edit_unit;
1101 return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
1103 /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */
1104 offset_temp += s->edit_unit_byte_count * s->index_duration;
1109 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);
1111 return AVERROR_INVALIDDATA;
1114 static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table)
1117 int8_t max_temporal_offset = -128;
1119 /* first compute how many entries we have */
1120 for (i = 0; i < index_table->nb_segments; i++) {
1121 MXFIndexTableSegment *s = index_table->segments[i];
1123 if (!s->nb_index_entries) {
1124 index_table->nb_ptses = 0;
1125 return 0; /* no TemporalOffsets */
1128 index_table->nb_ptses += s->index_duration;
1131 /* paranoid check */
1132 if (index_table->nb_ptses <= 0)
1135 if (!(index_table->ptses = av_calloc(index_table->nb_ptses, sizeof(int64_t))) ||
1136 !(index_table->fake_index = av_calloc(index_table->nb_ptses, sizeof(AVIndexEntry)))) {
1137 av_freep(&index_table->ptses);
1138 return AVERROR(ENOMEM);
1141 /* we may have a few bad TemporalOffsets
1142 * make sure the corresponding PTSes don't have the bogus value 0 */
1143 for (x = 0; x < index_table->nb_ptses; x++)
1144 index_table->ptses[x] = AV_NOPTS_VALUE;
1158 * We want to transform it into this:
1169 * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses,
1170 * then settings mxf->first_dts = -max(TemporalOffset[x]).
1171 * The latter makes DTS <= PTS.
1173 for (i = x = 0; i < index_table->nb_segments; i++) {
1174 MXFIndexTableSegment *s = index_table->segments[i];
1175 int index_delta = 1;
1176 int n = s->nb_index_entries;
1178 if (s->nb_index_entries == 2 * s->index_duration + 1) {
1179 index_delta = 2; /* Avid index */
1180 /* ignore the last entry - it's the size of the essence container */
1184 for (j = 0; j < n; j += index_delta, x++) {
1185 int offset = s->temporal_offset_entries[j] / index_delta;
1186 int index = x + offset;
1188 if (x >= index_table->nb_ptses) {
1189 av_log(mxf->fc, AV_LOG_ERROR,
1190 "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n",
1191 s->nb_index_entries, s->index_duration);
1195 index_table->fake_index[x].timestamp = x;
1196 index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0;
1198 if (index < 0 || index >= index_table->nb_ptses) {
1199 av_log(mxf->fc, AV_LOG_ERROR,
1200 "index entry %i + TemporalOffset %i = %i, which is out of bounds\n",
1205 index_table->ptses[index] = x;
1206 max_temporal_offset = FFMAX(max_temporal_offset, offset);
1210 index_table->first_dts = -max_temporal_offset;
1216 * Sorts and collects index table segments into index tables.
1217 * Also computes PTSes if possible.
1219 static int mxf_compute_index_tables(MXFContext *mxf)
1221 int i, j, k, ret, nb_sorted_segments;
1222 MXFIndexTableSegment **sorted_segments = NULL;
1224 if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) ||
1225 nb_sorted_segments <= 0) {
1226 av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n");
1230 /* sanity check and count unique BodySIDs/IndexSIDs */
1231 for (i = 0; i < nb_sorted_segments; i++) {
1232 if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid)
1233 mxf->nb_index_tables++;
1234 else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) {
1235 av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n");
1236 ret = AVERROR_INVALIDDATA;
1237 goto finish_decoding_index;
1241 if (!(mxf->index_tables = av_calloc(mxf->nb_index_tables, sizeof(MXFIndexTable)))) {
1242 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n");
1243 ret = AVERROR(ENOMEM);
1244 goto finish_decoding_index;
1247 /* distribute sorted segments to index tables */
1248 for (i = j = 0; i < nb_sorted_segments; i++) {
1249 if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) {
1254 mxf->index_tables[j].nb_segments++;
1257 for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) {
1258 MXFIndexTable *t = &mxf->index_tables[j];
1260 if (!(t->segments = av_calloc(t->nb_segments, sizeof(MXFIndexTableSegment*)))) {
1261 av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment pointer array\n");
1262 ret = AVERROR(ENOMEM);
1263 goto finish_decoding_index;
1266 if (sorted_segments[i]->index_start_position)
1267 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n",
1268 sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position);
1270 memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*));
1271 t->index_sid = sorted_segments[i]->index_sid;
1272 t->body_sid = sorted_segments[i]->body_sid;
1274 if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0)
1275 goto finish_decoding_index;
1277 /* fix zero IndexDurations */
1278 for (k = 0; k < t->nb_segments; k++) {
1279 if (t->segments[k]->index_duration)
1282 if (t->nb_segments > 1)
1283 av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n",
1286 if (mxf->fc->nb_streams <= 0) {
1287 av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n");
1291 /* assume the first stream's duration is reasonable
1292 * leave index_duration = 0 on further segments in case we have any (unlikely)
1294 t->segments[k]->index_duration = mxf->fc->streams[0]->duration;
1300 finish_decoding_index:
1301 av_free(sorted_segments);
1305 static int mxf_is_intra_only(MXFDescriptor *descriptor)
1307 return mxf_get_codec_ul(mxf_intra_only_essence_container_uls,
1308 &descriptor->essence_container_ul)->id != AV_CODEC_ID_NONE ||
1309 mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls,
1310 &descriptor->essence_codec_ul)->id != AV_CODEC_ID_NONE;
1313 static int mxf_add_timecode_metadata(AVDictionary **pm, const char *key, AVTimecode *tc)
1315 char buf[AV_TIMECODE_STR_SIZE];
1316 av_dict_set(pm, key, av_timecode_make_string(tc, buf, 0), 0);
1321 static int mxf_parse_structural_metadata(MXFContext *mxf)
1323 MXFPackage *material_package = NULL;
1324 MXFPackage *temp_package = NULL;
1327 av_dlog(mxf->fc, "metadata sets count %d\n", mxf->metadata_sets_count);
1328 /* TODO: handle multiple material packages (OP3x) */
1329 for (i = 0; i < mxf->packages_count; i++) {
1330 material_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[i], MaterialPackage);
1331 if (material_package) break;
1333 if (!material_package) {
1334 av_log(mxf->fc, AV_LOG_ERROR, "no material package found\n");
1335 return AVERROR_INVALIDDATA;
1338 for (i = 0; i < material_package->tracks_count; i++) {
1339 MXFPackage *source_package = NULL;
1340 MXFTrack *material_track = NULL;
1341 MXFTrack *source_track = NULL;
1342 MXFTrack *temp_track = NULL;
1343 MXFDescriptor *descriptor = NULL;
1344 MXFStructuralComponent *component = NULL;
1345 MXFTimecodeComponent *mxf_tc = NULL;
1346 UID *essence_container_ul = NULL;
1347 const MXFCodecUL *codec_ul = NULL;
1348 const MXFCodecUL *container_ul = NULL;
1349 const MXFCodecUL *pix_fmt_ul = NULL;
1354 if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) {
1355 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track strong ref\n");
1359 if ((component = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, TimecodeComponent))) {
1360 mxf_tc = (MXFTimecodeComponent*)component;
1361 flags = mxf_tc->drop_frame == 1 ? AV_TIMECODE_FLAG_DROPFRAME : 0;
1362 if (av_timecode_init(&tc, mxf_tc->rate, flags, mxf_tc->start_frame, mxf->fc) == 0) {
1363 mxf_add_timecode_metadata(&mxf->fc->metadata, "timecode", &tc);
1367 if (!(material_track->sequence = mxf_resolve_strong_ref(mxf, &material_track->sequence_ref, Sequence))) {
1368 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve material track sequence strong ref\n");
1372 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1373 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], 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);
1385 /* TODO: handle multiple source clips */
1386 for (j = 0; j < material_track->sequence->structural_components_count; j++) {
1387 component = mxf_resolve_strong_ref(mxf, &material_track->sequence->structural_components_refs[j], SourceClip);
1391 for (k = 0; k < mxf->packages_count; k++) {
1392 temp_package = mxf_resolve_strong_ref(mxf, &mxf->packages_refs[k], SourcePackage);
1395 if (!memcmp(temp_package->package_uid, component->source_package_uid, 16)) {
1396 source_package = temp_package;
1400 if (!source_package) {
1401 av_dlog(mxf->fc, "material track %d: no corresponding source package found\n", material_track->track_id);
1404 for (k = 0; k < source_package->tracks_count; k++) {
1405 if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) {
1406 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n");
1407 ret = AVERROR_INVALIDDATA;
1410 if (temp_track->track_id == component->source_track_id) {
1411 source_track = temp_track;
1415 if (!source_track) {
1416 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: no corresponding source track found\n", material_track->track_id);
1420 if (!source_track || !component)
1423 if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) {
1424 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n");
1425 ret = AVERROR_INVALIDDATA;
1429 /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf
1430 * This would result in both files appearing to have two streams. Work around this by sanity checking DataDefinition */
1431 if (memcmp(material_track->sequence->data_definition_ul, source_track->sequence->data_definition_ul, 16)) {
1432 av_log(mxf->fc, AV_LOG_ERROR, "material track %d: DataDefinition mismatch\n", material_track->track_id);
1436 st = avformat_new_stream(mxf->fc, NULL);
1438 av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n");
1439 ret = AVERROR(ENOMEM);
1442 st->id = source_track->track_id;
1443 st->priv_data = source_track;
1444 st->duration = component->duration;
1445 if (st->duration == -1)
1446 st->duration = AV_NOPTS_VALUE;
1447 st->start_time = component->start_position;
1448 if (material_track->edit_rate.num <= 0 || material_track->edit_rate.den <= 0) {
1449 av_log(mxf->fc, AV_LOG_WARNING,
1450 "invalid edit rate (%d/%d) found on stream #%d, defaulting to 25/1\n",
1451 material_track->edit_rate.num, material_track->edit_rate.den, st->index);
1452 material_track->edit_rate = (AVRational){25, 1};
1454 avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num);
1456 PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul);
1457 codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul);
1458 st->codec->codec_type = codec_ul->id;
1460 source_package->descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor_ref, AnyType);
1461 if (source_package->descriptor) {
1462 if (source_package->descriptor->type == MultipleDescriptor) {
1463 for (j = 0; j < source_package->descriptor->sub_descriptors_count; j++) {
1464 MXFDescriptor *sub_descriptor = mxf_resolve_strong_ref(mxf, &source_package->descriptor->sub_descriptors_refs[j], Descriptor);
1466 if (!sub_descriptor) {
1467 av_log(mxf->fc, AV_LOG_ERROR, "could not resolve sub descriptor strong ref\n");
1470 if (sub_descriptor->linked_track_id == source_track->track_id) {
1471 descriptor = sub_descriptor;
1475 } else if (source_package->descriptor->type == Descriptor)
1476 descriptor = source_package->descriptor;
1479 av_log(mxf->fc, AV_LOG_INFO, "source track %d: stream %d, no descriptor found\n", source_track->track_id, st->index);
1482 PRINT_KEY(mxf->fc, "essence codec ul", descriptor->essence_codec_ul);
1483 PRINT_KEY(mxf->fc, "essence container ul", descriptor->essence_container_ul);
1484 essence_container_ul = &descriptor->essence_container_ul;
1485 /* HACK: replacing the original key with mxf_encrypted_essence_container
1486 * is not allowed according to s429-6, try to find correct information anyway */
1487 if (IS_KLV_KEY(essence_container_ul, mxf_encrypted_essence_container)) {
1488 av_log(mxf->fc, AV_LOG_INFO, "broken encrypted mxf file\n");
1489 for (k = 0; k < mxf->metadata_sets_count; k++) {
1490 MXFMetadataSet *metadata = mxf->metadata_sets[k];
1491 if (metadata->type == CryptoContext) {
1492 essence_container_ul = &((MXFCryptoContext *)metadata)->source_container_ul;
1498 /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */
1499 codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul);
1500 st->codec->codec_id = (enum AVCodecID)codec_ul->id;
1501 if (descriptor->extradata) {
1502 st->codec->extradata = descriptor->extradata;
1503 st->codec->extradata_size = descriptor->extradata_size;
1505 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1506 source_track->intra_only = mxf_is_intra_only(descriptor);
1507 container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul);
1508 if (st->codec->codec_id == AV_CODEC_ID_NONE)
1509 st->codec->codec_id = container_ul->id;
1510 st->codec->width = descriptor->width;
1511 st->codec->height = descriptor->height; /* Field height, not frame height */
1512 switch (descriptor->frame_layout) {
1513 case SegmentedFrame:
1514 /* This one is a weird layout I don't fully understand. */
1515 av_log(mxf->fc, AV_LOG_INFO, "SegmentedFrame layout isn't currently supported\n");
1520 /* Every other line is stored and needs to be duplicated. */
1521 av_log(mxf->fc, AV_LOG_INFO, "OneField frame layout isn't currently supported\n");
1522 break; /* The correct thing to do here is fall through, but by breaking we might be
1523 able to decode some streams at half the vertical resolution, rather than not al all.
1524 It's also for compatibility with the old behavior. */
1527 case SeparateFields:
1528 st->codec->height *= 2; /* Turn field height into frame height. */
1531 av_log(mxf->fc, AV_LOG_INFO, "Unknown frame layout type: %d\n", descriptor->frame_layout);
1533 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) {
1534 st->codec->pix_fmt = descriptor->pix_fmt;
1535 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1536 pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls,
1537 &descriptor->essence_codec_ul);
1538 st->codec->pix_fmt = (enum AVPixelFormat)pix_fmt_ul->id;
1539 if (st->codec->pix_fmt == AV_PIX_FMT_NONE) {
1540 /* support files created before RP224v10 by defaulting to UYVY422
1541 if subsampling is 4:2:2 and component depth is 8-bit */
1542 if (descriptor->horiz_subsampling == 2 &&
1543 descriptor->vert_subsampling == 1 &&
1544 descriptor->component_depth == 8) {
1545 st->codec->pix_fmt = AV_PIX_FMT_UYVY422;
1550 st->need_parsing = AVSTREAM_PARSE_HEADERS;
1551 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1552 container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul);
1553 /* Only overwrite existing codec ID if it is unset or A-law, which is the default according to SMPTE RP 224. */
1554 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))
1555 st->codec->codec_id = (enum AVCodecID)container_ul->id;
1556 st->codec->channels = descriptor->channels;
1557 st->codec->bits_per_coded_sample = descriptor->bits_per_sample;
1559 if (descriptor->sample_rate.den > 0) {
1560 avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num);
1561 st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den;
1563 av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) found for stream #%d, time base forced to 1/48000\n",
1564 descriptor->sample_rate.num, descriptor->sample_rate.den, st->index);
1565 avpriv_set_pts_info(st, 64, 1, 48000);
1568 /* TODO: implement AV_CODEC_ID_RAWAUDIO */
1569 if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) {
1570 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1571 st->codec->codec_id = AV_CODEC_ID_PCM_S24LE;
1572 else if (descriptor->bits_per_sample == 32)
1573 st->codec->codec_id = AV_CODEC_ID_PCM_S32LE;
1574 } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) {
1575 if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24)
1576 st->codec->codec_id = AV_CODEC_ID_PCM_S24BE;
1577 else if (descriptor->bits_per_sample == 32)
1578 st->codec->codec_id = AV_CODEC_ID_PCM_S32BE;
1579 } else if (st->codec->codec_id == AV_CODEC_ID_MP2) {
1580 st->need_parsing = AVSTREAM_PARSE_FULL;
1583 if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
1584 /* TODO: decode timestamps */
1585 st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
1594 static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = {
1595 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack },
1596 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack },
1597 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack },
1598 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack },
1599 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack },
1600 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack },
1601 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack },
1602 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack },
1603 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack },
1604 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack },
1605 { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack },
1606 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType },
1607 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage },
1608 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage },
1609 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence },
1610 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip },
1611 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor },
1612 { { 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 */
1613 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */
1614 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */
1615 { { 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 */
1616 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */
1617 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */
1618 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */
1619 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */
1620 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x14,0x00 }, mxf_read_timecode_component, sizeof(MXFTimecodeComponent), TimecodeComponent },
1621 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext },
1622 { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment },
1623 { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType },
1626 static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
1628 AVIOContext *pb = mxf->fc->pb;
1629 MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
1630 uint64_t klv_end = avio_tell(pb) + klv->length;
1633 return AVERROR(ENOMEM);
1634 while (avio_tell(pb) + 4 < klv_end && !url_feof(pb)) {
1636 int tag = avio_rb16(pb);
1637 int size = avio_rb16(pb); /* KLV specified by 0x53 */
1638 uint64_t next = avio_tell(pb) + size;
1641 av_dlog(mxf->fc, "local tag %#04x size %d\n", tag, size);
1642 if (!size) { /* ignore empty tag, needed for some files with empty UMID tag */
1643 av_log(mxf->fc, AV_LOG_ERROR, "local tag %#04x with 0 size\n", tag);
1646 if (tag > 0x7FFF) { /* dynamic tag */
1648 for (i = 0; i < mxf->local_tags_count; i++) {
1649 int local_tag = AV_RB16(mxf->local_tags+i*18);
1650 if (local_tag == tag) {
1651 memcpy(uid, mxf->local_tags+i*18+2, 16);
1652 av_dlog(mxf->fc, "local tag %#04x\n", local_tag);
1653 PRINT_KEY(mxf->fc, "uid", uid);
1657 if (ctx_size && tag == 0x3C0A)
1658 avio_read(pb, ctx->uid, 16);
1659 else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0)
1662 /* Accept the 64k local set limit being exceeded (Avid). Don't accept
1663 * it extending past the end of the KLV though (zzuf5.mxf). */
1664 if (avio_tell(pb) > klv_end) {
1668 av_log(mxf->fc, AV_LOG_ERROR,
1669 "local tag %#04x extends past end of local set @ %#"PRIx64"\n",
1671 return AVERROR_INVALIDDATA;
1672 } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */
1673 avio_seek(pb, next, SEEK_SET);
1675 if (ctx_size) ctx->type = type;
1676 return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0;
1680 * Seeks to the previous partition, if possible
1681 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1683 static int mxf_seek_to_previous_partition(MXFContext *mxf)
1685 AVIOContext *pb = mxf->fc->pb;
1687 if (!mxf->current_partition ||
1688 mxf->run_in + mxf->current_partition->previous_partition <= mxf->last_forward_tell)
1689 return 0; /* we've parsed all partitions */
1691 /* seek to previous partition */
1692 avio_seek(pb, mxf->run_in + mxf->current_partition->previous_partition, SEEK_SET);
1693 mxf->current_partition = NULL;
1695 av_dlog(mxf->fc, "seeking to previous partition\n");
1701 * Called when essence is encountered
1702 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1704 static int mxf_parse_handle_essence(MXFContext *mxf)
1706 AVIOContext *pb = mxf->fc->pb;
1709 if (mxf->parsing_backward) {
1710 return mxf_seek_to_previous_partition(mxf);
1712 if (!mxf->footer_partition) {
1713 av_dlog(mxf->fc, "no footer\n");
1717 av_dlog(mxf->fc, "seeking to footer\n");
1719 /* remember where we were so we don't end up seeking further back than this */
1720 mxf->last_forward_tell = avio_tell(pb);
1722 if (!pb->seekable) {
1723 av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n");
1727 /* seek to footer partition and parse backward */
1728 if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) {
1729 av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n",
1730 mxf->run_in + mxf->footer_partition, ret);
1734 mxf->current_partition = NULL;
1735 mxf->parsing_backward = 1;
1742 * Called when the next partition or EOF is encountered
1743 * @return <= 0 if we should stop parsing, > 0 if we should keep going
1745 static int mxf_parse_handle_partition_or_eof(MXFContext *mxf)
1747 return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
1751 * Figures out the proper offset and length of the essence container in each partition
1753 static void mxf_compute_essence_containers(MXFContext *mxf)
1757 /* everything is already correct */
1758 if (mxf->op == OPAtom)
1761 for (x = 0; x < mxf->partitions_count; x++) {
1762 MXFPartition *p = &mxf->partitions[x];
1765 continue; /* BodySID == 0 -> no essence */
1767 if (x >= mxf->partitions_count - 1)
1768 break; /* last partition - can't compute length (and we don't need to) */
1770 /* essence container spans to the next partition */
1771 p->essence_length = mxf->partitions[x+1].this_partition - p->essence_offset;
1773 if (p->essence_length < 0) {
1774 /* next ThisPartition < essence_offset */
1775 p->essence_length = 0;
1776 av_log(mxf->fc, AV_LOG_ERROR,
1777 "partition %i: bad ThisPartition = %"PRIX64"\n",
1778 x+1, mxf->partitions[x+1].this_partition);
1783 static int64_t round_to_kag(int64_t position, int kag_size)
1785 /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
1786 /* NOTE: kag_size may be any integer between 1 - 2^10 */
1787 int64_t ret = (position / kag_size) * kag_size;
1788 return ret == position ? ret : ret + kag_size;
1791 static int is_pcm(enum AVCodecID codec_id)
1793 /* we only care about "normal" PCM codecs until we get samples */
1794 return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
1798 * Deal with the case where for some audio atoms EditUnitByteCount is
1799 * very small (2, 4..). In those cases we should read more than one
1800 * sample per call to mxf_read_packet().
1802 static void mxf_handle_small_eubc(AVFormatContext *s)
1804 MXFContext *mxf = s->priv_data;
1806 /* assuming non-OPAtom == frame wrapped
1807 * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
1808 if (mxf->op != OPAtom)
1811 /* expect PCM with exactly one index table segment and a small (< 32) EUBC */
1812 if (s->nb_streams != 1 ||
1813 s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO ||
1814 !is_pcm(s->streams[0]->codec->codec_id) ||
1815 mxf->nb_index_tables != 1 ||
1816 mxf->index_tables[0].nb_segments != 1 ||
1817 mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32)
1820 /* arbitrarily default to 48 kHz PAL audio frame size */
1821 /* TODO: We could compute this from the ratio between the audio
1822 * and video edit rates for 48 kHz NTSC we could use the
1823 * 1802-1802-1802-1802-1801 pattern. */
1824 mxf->edit_units_per_packet = 1920;
1827 static int mxf_read_header(AVFormatContext *s)
1829 MXFContext *mxf = s->priv_data;
1831 int64_t essence_offset = 0;
1834 mxf->last_forward_tell = INT64_MAX;
1835 mxf->edit_units_per_packet = 1;
1837 if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
1838 av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n");
1839 return AVERROR_INVALIDDATA;
1841 avio_seek(s->pb, -14, SEEK_CUR);
1843 mxf->run_in = avio_tell(s->pb);
1845 while (!url_feof(s->pb)) {
1846 const MXFMetadataReadTableEntry *metadata;
1848 if (klv_read_packet(&klv, s->pb) < 0) {
1849 /* EOF - seek to previous partition or stop */
1850 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1856 PRINT_KEY(s, "read header", klv.key);
1857 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
1858 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) ||
1859 IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
1860 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
1861 IS_KLV_KEY(klv.key, mxf_system_item_key)) {
1863 if (!mxf->current_partition) {
1864 av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to first PartitionPack\n");
1865 return AVERROR_INVALIDDATA;
1868 if (!mxf->current_partition->essence_offset) {
1869 /* for OP1a we compute essence_offset
1870 * for OPAtom we point essence_offset after the KL (usually op1a_essence_offset + 20 or 25)
1871 * TODO: for OP1a we could eliminate this entire if statement, always stopping parsing at op1a_essence_offset
1872 * for OPAtom we still need the actual essence_offset though (the KL's length can vary)
1874 int64_t op1a_essence_offset =
1875 round_to_kag(mxf->current_partition->this_partition +
1876 mxf->current_partition->pack_length, mxf->current_partition->kag_size) +
1877 round_to_kag(mxf->current_partition->header_byte_count, mxf->current_partition->kag_size) +
1878 round_to_kag(mxf->current_partition->index_byte_count, mxf->current_partition->kag_size);
1880 if (mxf->op == OPAtom) {
1881 /* point essence_offset to the actual data
1882 * OPAtom has all the essence in one big KLV
1884 mxf->current_partition->essence_offset = avio_tell(s->pb);
1885 mxf->current_partition->essence_length = klv.length;
1887 /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
1888 mxf->current_partition->essence_offset = op1a_essence_offset;
1892 if (!essence_offset)
1893 essence_offset = klv.offset;
1895 /* seek to footer, previous partition or stop */
1896 if (mxf_parse_handle_essence(mxf) <= 0)
1899 } else if (!memcmp(klv.key, mxf_header_partition_pack_key, 13) &&
1900 klv.key[13] >= 2 && klv.key[13] <= 4 && mxf->current_partition) {
1901 /* next partition pack - keep going, seek to previous partition or stop */
1902 if(mxf_parse_handle_partition_or_eof(mxf) <= 0)
1904 else if (mxf->parsing_backward)
1906 /* we're still parsing forward. proceed to parsing this partition pack */
1909 for (metadata = mxf_metadata_read_table; metadata->read; metadata++) {
1910 if (IS_KLV_KEY(klv.key, metadata->key)) {
1912 if (klv.key[5] == 0x53) {
1913 res = mxf_read_local_tags(mxf, &klv, metadata->read, metadata->ctx_size, metadata->type);
1915 uint64_t next = avio_tell(s->pb) + klv.length;
1916 res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset);
1918 /* only seek forward, else this can loop for a long time */
1919 if (avio_tell(s->pb) > next) {
1920 av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n",
1922 return AVERROR_INVALIDDATA;
1925 avio_seek(s->pb, next, SEEK_SET);
1928 av_log(s, AV_LOG_ERROR, "error reading header metadata\n");
1934 if (!metadata->read)
1935 avio_skip(s->pb, klv.length);
1937 /* FIXME avoid seek */
1938 if (!essence_offset) {
1939 av_log(s, AV_LOG_ERROR, "no essence\n");
1940 return AVERROR_INVALIDDATA;
1942 avio_seek(s->pb, essence_offset, SEEK_SET);
1944 mxf_compute_essence_containers(mxf);
1946 /* we need to do this before computing the index tables
1947 * to be able to fill in zero IndexDurations with st->duration */
1948 if ((ret = mxf_parse_structural_metadata(mxf)) < 0)
1951 if ((ret = mxf_compute_index_tables(mxf)) < 0)
1954 if (mxf->nb_index_tables > 1) {
1955 /* TODO: look up which IndexSID to use via EssenceContainerData */
1956 av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n",
1957 mxf->nb_index_tables, mxf->index_tables[0].index_sid);
1958 } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) {
1959 av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
1960 ret = AVERROR_INVALIDDATA;
1964 mxf_handle_small_eubc(s);
1974 * Sets mxf->current_edit_unit based on what offset we're currently at.
1975 * @return next_ofs if OK, <0 on error
1977 static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset)
1979 int64_t last_ofs = -1, next_ofs = -1;
1980 MXFIndexTable *t = &mxf->index_tables[0];
1982 /* this is called from the OP1a demuxing logic, which means there
1983 * may be no index tables */
1984 if (mxf->nb_index_tables <= 0)
1987 /* find mxf->current_edit_unit so that the next edit unit starts ahead of current_offset */
1988 while (mxf->current_edit_unit >= 0) {
1989 if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, NULL, &next_ofs, 0) < 0)
1992 if (next_ofs <= last_ofs) {
1993 /* large next_ofs didn't change or current_edit_unit wrapped
1994 * around this fixes the infinite loop on zzuf3.mxf */
1995 av_log(mxf->fc, AV_LOG_ERROR,
1996 "next_ofs didn't change. not deriving packet timestamps\n");
2000 if (next_ofs > current_offset)
2003 last_ofs = next_ofs;
2004 mxf->current_edit_unit++;
2007 /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files may lack IndexEntryArrays */
2008 if (mxf->current_edit_unit < 0)
2014 static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, uint64_t *sample_count)
2016 int i, total = 0, size = 0;
2017 AVStream *st = mxf->fc->streams[stream_index];
2018 MXFTrack *track = st->priv_data;
2019 AVRational time_base = av_inv_q(track->edit_rate);
2020 AVRational sample_rate = av_inv_q(st->time_base);
2021 const MXFSamplesPerFrame *spf = NULL;
2023 if ((sample_rate.num / sample_rate.den) == 48000)
2024 spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base);
2026 int remainder = (sample_rate.num * time_base.num) % (time_base.den * sample_rate.den);
2027 *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1},
2028 av_mul_q(sample_rate, time_base)));
2030 av_log(mxf->fc, AV_LOG_WARNING,
2031 "seeking detected on stream #%d with time base (%d/%d) and sample rate (%d/%d), audio pts won't be accurate.\n",
2032 stream_index, time_base.num, time_base.den, sample_rate.num, sample_rate.den);
2036 while (spf->samples_per_frame[size]) {
2037 total += spf->samples_per_frame[size];
2043 *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total;
2044 for (i = 0; i < mxf->current_edit_unit % size; i++) {
2045 *sample_count += spf->samples_per_frame[i];
2051 static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, AVPacket *pkt)
2053 MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data;
2054 pkt->pts = track->sample_count;
2055 track->sample_count += pkt->size / (codec->channels * av_get_bits_per_sample(codec->codec_id) / 8);
2059 static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
2062 MXFContext *mxf = s->priv_data;
2064 while (!url_feof(s->pb)) {
2066 if (klv_read_packet(&klv, s->pb) < 0)
2068 PRINT_KEY(s, "read packet", klv.key);
2069 av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset);
2070 if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) {
2071 ret = mxf_decrypt_triplet(s, pkt, &klv);
2073 av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n");
2074 return AVERROR_INVALIDDATA;
2078 if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
2079 IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) {
2080 int index = mxf_get_stream_index(s, &klv);
2081 int64_t next_ofs, next_klv;
2084 AVCodecContext *codec;
2087 av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12));
2091 st = s->streams[index];
2092 track = st->priv_data;
2094 if (s->streams[index]->discard == AVDISCARD_ALL)
2097 next_klv = avio_tell(s->pb) + klv.length;
2098 next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
2100 if (next_ofs >= 0 && next_klv > next_ofs) {
2101 /* if this check is hit then it's possible OPAtom was treated as OP1a
2102 * truncate the packet since it's probably very large (>2 GiB is common) */
2103 av_log_ask_for_sample(s,
2104 "KLV for edit unit %i extends into next edit unit - OPAtom misinterpreted as OP1a?\n",
2105 mxf->current_edit_unit);
2106 klv.length = next_ofs - avio_tell(s->pb);
2109 /* check for 8 channels AES3 element */
2110 if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) {
2111 if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) {
2112 av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
2113 return AVERROR_INVALIDDATA;
2116 ret = av_get_packet(s->pb, pkt, klv.length);
2120 pkt->stream_index = index;
2121 pkt->pos = klv.offset;
2123 codec = s->streams[index]->codec;
2124 if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) {
2125 /* mxf->current_edit_unit good - see if we have an index table to derive timestamps from */
2126 MXFIndexTable *t = &mxf->index_tables[0];
2128 if (mxf->nb_index_tables >= 1 && mxf->current_edit_unit < t->nb_ptses) {
2129 pkt->dts = mxf->current_edit_unit + t->first_dts;
2130 pkt->pts = t->ptses[mxf->current_edit_unit];
2131 } else if (track->intra_only) {
2132 /* intra-only -> PTS = EditUnit.
2133 * let utils.c figure out DTS since it can be < PTS if low_delay = 0 (Sony IMX30) */
2134 pkt->pts = mxf->current_edit_unit;
2136 } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2137 int ret = mxf_set_audio_pts(mxf, codec, pkt);
2142 /* seek for truncated packets */
2143 avio_seek(s->pb, next_klv, SEEK_SET);
2148 avio_skip(s->pb, klv.length);
2153 static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
2155 MXFContext *mxf = s->priv_data;
2157 int64_t ret64, pos, next_pos;
2162 if (mxf->op != OPAtom)
2163 return mxf_read_packet_old(s, pkt);
2165 /* OPAtom - clip wrapped demuxing */
2166 /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
2168 t = &mxf->index_tables[0];
2170 if (mxf->current_edit_unit >= st->duration)
2173 edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit);
2175 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0)
2178 /* compute size by finding the next edit unit or the end of the essence container
2179 * not pretty, but it works */
2180 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 &&
2181 (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
2182 av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
2183 return AVERROR_INVALIDDATA;
2186 if ((size = next_pos - pos) <= 0) {
2187 av_log(s, AV_LOG_ERROR, "bad size: %i\n", size);
2188 return AVERROR_INVALIDDATA;
2191 if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0)
2194 if ((size = av_get_packet(s->pb, pkt, size)) < 0)
2197 pkt->stream_index = 0;
2199 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses &&
2200 mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) {
2201 pkt->dts = mxf->current_edit_unit + t->first_dts;
2202 pkt->pts = t->ptses[mxf->current_edit_unit];
2203 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2204 int ret = mxf_set_audio_pts(mxf, st->codec, pkt);
2209 mxf->current_edit_unit += edit_units;
2214 static int mxf_read_close(AVFormatContext *s)
2216 MXFContext *mxf = s->priv_data;
2217 MXFIndexTableSegment *seg;
2220 av_freep(&mxf->packages_refs);
2222 for (i = 0; i < s->nb_streams; i++)
2223 s->streams[i]->priv_data = NULL;
2225 for (i = 0; i < mxf->metadata_sets_count; i++) {
2226 switch (mxf->metadata_sets[i]->type) {
2227 case MultipleDescriptor:
2228 av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs);
2231 av_freep(&((MXFSequence *)mxf->metadata_sets[i])->structural_components_refs);
2234 case MaterialPackage:
2235 av_freep(&((MXFPackage *)mxf->metadata_sets[i])->tracks_refs);
2237 case IndexTableSegment:
2238 seg = (MXFIndexTableSegment *)mxf->metadata_sets[i];
2239 av_freep(&seg->temporal_offset_entries);
2240 av_freep(&seg->flag_entries);
2241 av_freep(&seg->stream_offset_entries);
2246 av_freep(&mxf->metadata_sets[i]);
2248 av_freep(&mxf->partitions);
2249 av_freep(&mxf->metadata_sets);
2250 av_freep(&mxf->aesc);
2251 av_freep(&mxf->local_tags);
2253 for (i = 0; i < mxf->nb_index_tables; i++) {
2254 av_freep(&mxf->index_tables[i].segments);
2255 av_freep(&mxf->index_tables[i].ptses);
2256 av_freep(&mxf->index_tables[i].fake_index);
2258 av_freep(&mxf->index_tables);
2263 static int mxf_probe(AVProbeData *p) {
2264 uint8_t *bufp = p->buf;
2265 uint8_t *end = p->buf + p->buf_size;
2267 if (p->buf_size < sizeof(mxf_header_partition_pack_key))
2270 /* Must skip Run-In Sequence and search for MXF header partition pack key SMPTE 377M 5.5 */
2271 end -= sizeof(mxf_header_partition_pack_key);
2272 for (; bufp < end; bufp++) {
2273 if (IS_KLV_KEY(bufp, mxf_header_partition_pack_key))
2274 return AVPROBE_SCORE_MAX;
2279 /* rudimentary byte seek */
2280 /* XXX: use MXF Index */
2281 static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
2283 AVStream *st = s->streams[stream_index];
2285 MXFContext* mxf = s->priv_data;
2290 if (mxf->nb_index_tables <= 0) {
2292 return AVERROR_INVALIDDATA;
2293 if (sample_time < 0)
2295 seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den);
2297 if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0)
2299 ff_update_cur_dts(s, st, sample_time);
2301 t = &mxf->index_tables[0];
2303 /* clamp above zero, else ff_index_search_timestamp() returns negative
2304 * this also means we allow seeking before the start */
2305 sample_time = FFMAX(sample_time, 0);
2307 if (t->fake_index) {
2308 /* behave as if we have a proper index */
2309 if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0)
2312 /* no IndexEntryArray (one or more CBR segments)
2313 * make sure we don't seek past the end */
2314 sample_time = FFMIN(sample_time, st->duration - 1);
2317 if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0)
2320 ff_update_cur_dts(s, st, sample_time);
2321 mxf->current_edit_unit = sample_time;
2322 avio_seek(s->pb, seekpos, SEEK_SET);
2325 // Update all tracks sample count
2326 for (i = 0; i < s->nb_streams; i++) {
2327 AVStream *cur_st = s->streams[i];
2328 MXFTrack *cur_track = cur_st->priv_data;
2329 uint64_t current_sample_count = 0;
2330 if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2331 ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
2335 cur_track->sample_count = current_sample_count;
2341 AVInputFormat ff_mxf_demuxer = {
2343 .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"),
2344 .priv_data_size = sizeof(MXFContext),
2345 .read_probe = mxf_probe,
2346 .read_header = mxf_read_header,
2347 .read_packet = mxf_read_packet,
2348 .read_close = mxf_read_close,
2349 .read_seek = mxf_read_seek,