X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Fmxfdec.c;h=b71c80f14be1691508e4318f049a1f62a4de8858;hb=2ded57371abead879bcee56da5131e5fac0d17ef;hp=c45e225d8f74046de158cc11a59e7bc9c48a0f5b;hpb=3cb33fbe919d3664977e88a1ce4554a330ccc48a;p=ffmpeg diff --git a/libavformat/mxfdec.c b/libavformat/mxfdec.c index c45e225d8f7..b71c80f14be 100644 --- a/libavformat/mxfdec.c +++ b/libavformat/mxfdec.c @@ -43,7 +43,7 @@ * Only tracks with associated descriptors will be decoded. "Highly Desirable" SMPTE 377M D.1 */ -//#define DEBUG +#include #include "libavutil/aes.h" #include "libavutil/mathematics.h" @@ -59,7 +59,7 @@ typedef enum { } MXFPartitionType; typedef enum { - OP1a, + OP1a = 1, OP1b, OP1c, OP2a, @@ -111,6 +111,7 @@ typedef struct { UID *structural_components_refs; int structural_components_count; int64_t duration; + uint8_t origin; } MXFSequence; typedef struct { @@ -121,6 +122,9 @@ typedef struct { int track_id; uint8_t track_number[4]; AVRational edit_rate; + int intra_only; + uint64_t sample_count; + int64_t original_duration; /* st->duration in SampleRate/EditRate units */ } MXFTrack; typedef struct { @@ -131,15 +135,22 @@ typedef struct { AVRational sample_rate; AVRational aspect_ratio; int width; - int height; + int height; /* Field height, not frame height */ + int frame_layout; /* See MXFFrameLayout enum */ +#define MXF_TFF 1 +#define MXF_BFF 2 + int field_dominance; int channels; int bits_per_sample; + unsigned int component_depth; + unsigned int horiz_subsampling; + unsigned int vert_subsampling; UID *sub_descriptors_refs; int sub_descriptors_count; int linked_track_id; uint8_t *extradata; int extradata_size; - enum PixelFormat pix_fmt; + enum AVPixelFormat pix_fmt; } MXFDescriptor; typedef struct { @@ -148,17 +159,12 @@ typedef struct { int edit_unit_byte_count; int index_sid; int body_sid; - int slice_count; AVRational index_edit_rate; uint64_t index_start_position; uint64_t index_duration; - int *slice; - int *element_delta; - int nb_delta_entries; int8_t *temporal_offset_entries; int *flag_entries; uint64_t *stream_offset_entries; - uint32_t **slice_offset_entries; int nb_index_entries; } MXFIndexTableSegment; @@ -177,6 +183,18 @@ typedef struct { enum MXFMetadataSetType type; } MXFMetadataSet; +/* decoded index table */ +typedef struct { + int index_sid; + int body_sid; + int nb_ptses; /* number of PTSes or total duration of index */ + int64_t first_dts; /* DTS = EditUnit + first_dts */ + int64_t *ptses; /* maps EditUnit -> PTS */ + int nb_segments; + MXFIndexTableSegment **segments; /* sorted by IndexStartPosition */ + AVIndexEntry *fake_index; /* used for calling ff_index_search_timestamp() */ +} MXFIndexTable; + typedef struct { MXFPartition *partitions; unsigned partitions_count; @@ -189,6 +207,7 @@ typedef struct { struct AVAES *aesc; uint8_t *local_tags; int local_tags_count; + uint64_t last_partition; uint64_t footer_partition; KLVPacket current_klv_data; int current_klv_index; @@ -197,6 +216,10 @@ typedef struct { int parsing_backward; int64_t last_forward_tell; int last_forward_partition; + int current_edit_unit; + int nb_index_tables; + MXFIndexTable *index_tables; + int edit_units_per_packet; ///< how many edit units to read at a time (PCM, OPAtom) } MXFContext; enum MXFWrappingScheme { @@ -217,12 +240,14 @@ typedef struct { /* partial keys to match */ static const uint8_t mxf_header_partition_pack_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02 }; static const uint8_t mxf_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0d,0x01,0x03,0x01 }; -static const uint8_t mxf_system_item_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x03,0x01,0x04 }; +static const uint8_t mxf_avid_essence_element_key[] = { 0x06,0x0e,0x2b,0x34,0x01,0x02,0x01,0x01,0x0e,0x04,0x03,0x01 }; +static const uint8_t mxf_system_item_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x03,0x01,0x04 }; static const uint8_t mxf_klv_key[] = { 0x06,0x0e,0x2b,0x34 }; /* complete keys to match */ 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 }; static const uint8_t mxf_encrypted_triplet_key[] = { 0x06,0x0e,0x2b,0x34,0x02,0x04,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x7e,0x01,0x00 }; static const uint8_t mxf_encrypted_essence_container[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x0d,0x01,0x03,0x01,0x02,0x0b,0x01,0x00 }; +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 }; static const uint8_t mxf_sony_mpeg4_extradata[] = { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0e,0x06,0x06,0x02,0x02,0x01,0x00,0x00 }; #define IS_KLV_KEY(x, y) (!memcmp(x, y, sizeof(y))) @@ -295,7 +320,7 @@ static int mxf_get_d10_aes3_packet(AVIOContext *pb, AVStream *st, AVPacket *pkt, data_ptr = pkt->data; end_ptr = pkt->data + length; buf_ptr = pkt->data + 4; /* skip SMPTE 331M header */ - for (; buf_ptr + st->codec->channels*4 < end_ptr; ) { + for (; end_ptr - buf_ptr >= st->codec->channels * 4; ) { for (i = 0; i < st->codec->channels; i++) { uint32_t sample = bytestream_get_le32(&buf_ptr); if (st->codec->bits_per_coded_sample == 24) @@ -323,7 +348,7 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv int index; if (!mxf->aesc && s->key && s->keylen == 16) { - mxf->aesc = av_malloc(av_aes_size); + mxf->aesc = av_aes_alloc(); if (!mxf->aesc) return AVERROR(ENOMEM); av_aes_init(mxf->aesc, s->key, 128, 1); @@ -372,53 +397,6 @@ static int mxf_decrypt_triplet(AVFormatContext *s, AVPacket *pkt, KLVPacket *klv return 0; } -static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt) -{ - KLVPacket klv; - - while (!s->pb->eof_reached) { - int ret; - if (klv_read_packet(&klv, s->pb) < 0) - return -1; - PRINT_KEY(s, "read packet", klv.key); - av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); - if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) { - ret = mxf_decrypt_triplet(s, pkt, &klv); - if (ret < 0) { - av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n"); - return AVERROR_INVALIDDATA; - } - return 0; - } - if (IS_KLV_KEY(klv.key, mxf_essence_element_key)) { - int index = mxf_get_stream_index(s, &klv); - if (index < 0) { - av_log(s, AV_LOG_ERROR, "error getting stream index %d\n", AV_RB32(klv.key+12)); - goto skip; - } - if (s->streams[index]->discard == AVDISCARD_ALL) - goto skip; - /* check for 8 channels AES3 element */ - if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) { - if (mxf_get_d10_aes3_packet(s->pb, s->streams[index], pkt, klv.length) < 0) { - av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n"); - return AVERROR_INVALIDDATA; - } - } else { - ret = av_get_packet(s->pb, pkt, klv.length); - if (ret < 0) - return ret; - } - pkt->stream_index = index; - pkt->pos = klv.offset; - return 0; - } else - skip: - avio_skip(s->pb, klv.length); - } - return AVERROR_EOF; -} - static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) { MXFContext *mxf = arg; @@ -426,8 +404,7 @@ static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, U int item_len = avio_rb32(pb); if (item_len != 18) { - av_log_ask_for_sample(pb, "unsupported primer pack item length %d\n", - item_len); + avpriv_request_sample(pb, "Primer pack item length %d", item_len); return AVERROR_PATCHWELCOME; } if (item_num > UINT_MAX / item_len) @@ -446,13 +423,14 @@ static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size MXFPartition *partition; UID op; uint64_t footer_partition; + uint32_t nb_essence_containers; + int err; - if (mxf->partitions_count+1 >= UINT_MAX / sizeof(*mxf->partitions)) - return AVERROR(ENOMEM); - - mxf->partitions = av_realloc(mxf->partitions, (mxf->partitions_count + 1) * sizeof(*mxf->partitions)); - if (!mxf->partitions) - return AVERROR(ENOMEM); + if ((err = av_reallocp_array(&mxf->partitions, mxf->partitions_count + 1, + sizeof(*mxf->partitions))) < 0) { + mxf->partitions_count = 0; + return err; + } if (mxf->parsing_backward) { /* insert the new partition pack in the middle @@ -499,23 +477,55 @@ static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size avio_skip(pb, 8); partition->body_sid = avio_rb32(pb); avio_read(pb, op, sizeof(UID)); + nb_essence_containers = avio_rb32(pb); + + if (partition->this_partition && + partition->previous_partition == partition->this_partition) { + av_log(mxf->fc, AV_LOG_ERROR, + "PreviousPartition equal to ThisPartition %"PRIx64"\n", + partition->previous_partition); + /* override with the actual previous partition offset */ + if (!mxf->parsing_backward && mxf->last_forward_partition > 1) { + MXFPartition *prev = + mxf->partitions + mxf->last_forward_partition - 2; + partition->previous_partition = prev->this_partition; + } + /* if no previous body partition are found point to the header + * partition */ + if (partition->previous_partition == partition->this_partition) + partition->previous_partition = 0; + av_log(mxf->fc, AV_LOG_ERROR, + "Overriding PreviousPartition with %"PRIx64"\n", + partition->previous_partition); + } /* some files don'thave FooterPartition set in every partition */ if (footer_partition) { if (mxf->footer_partition && mxf->footer_partition != footer_partition) { - av_log(mxf->fc, AV_LOG_ERROR, "inconsistent FooterPartition value: %li != %li\n", + av_log(mxf->fc, AV_LOG_ERROR, + "inconsistent FooterPartition value: %"PRIu64" != %"PRIu64"\n", mxf->footer_partition, footer_partition); } else { mxf->footer_partition = footer_partition; } } - av_dlog(mxf->fc, "PartitionPack: ThisPartition = 0x%lx, PreviousPartition = 0x%lx, " - "FooterPartition = 0x%lx, IndexSID = %i, BodySID = %i\n", + av_dlog(mxf->fc, + "PartitionPack: ThisPartition = 0x%"PRIX64 + ", PreviousPartition = 0x%"PRIX64", " + "FooterPartition = 0x%"PRIX64", IndexSID = %i, BodySID = %i\n", partition->this_partition, partition->previous_partition, footer_partition, partition->index_sid, partition->body_sid); + /* sanity check PreviousPartition if set */ + if (partition->previous_partition && + mxf->run_in + partition->previous_partition >= klv_offset) { + av_log(mxf->fc, AV_LOG_ERROR, + "PreviousPartition points to this partition or forward\n"); + return AVERROR_INVALIDDATA; + } + if (op[12] == 1 && op[13] == 1) mxf->op = OP1a; else if (op[12] == 1 && op[13] == 2) mxf->op = OP1b; else if (op[12] == 1 && op[13] == 3) mxf->op = OP1c; @@ -525,22 +535,40 @@ static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size else if (op[12] == 3 && op[13] == 1) mxf->op = OP3a; else if (op[12] == 3 && op[13] == 2) mxf->op = OP3b; else if (op[12] == 3 && op[13] == 3) mxf->op = OP3c; - else if (op[12] == 0x10) mxf->op = OPAtom; else if (op[12] == 64&& op[13] == 1) mxf->op = OPSonyOpt; - else { + else if (op[12] == 0x10) { + /* SMPTE 390m: "There shall be exactly one essence container" + * The following block deals with files that violate this, namely: + * 2011_DCPTEST_24FPS.V.mxf - two ECs, OP1a + * abcdefghiv016f56415e.mxf - zero ECs, OPAtom, output by Avid AirSpeed */ + if (nb_essence_containers != 1) { + MXFOP op = nb_essence_containers ? OP1a : OPAtom; + + /* only nag once */ + if (!mxf->op) + av_log(mxf->fc, AV_LOG_WARNING, + "\"OPAtom\" with %"PRIu32" ECs - assuming %s\n", + nb_essence_containers, + op == OP1a ? "OP1a" : "OPAtom"); + + mxf->op = op; + } else + mxf->op = OPAtom; + } else { av_log(mxf->fc, AV_LOG_ERROR, "unknown operational pattern: %02xh %02xh - guessing OP1a\n", op[12], op[13]); mxf->op = OP1a; } if (partition->kag_size <= 0 || partition->kag_size > (1 << 20)) { - av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %i - guessing ", partition->kag_size); + av_log(mxf->fc, AV_LOG_WARNING, "invalid KAGSize %"PRId32" - guessing ", + partition->kag_size); if (mxf->op == OPSonyOpt) partition->kag_size = 512; else partition->kag_size = 1; - av_log(mxf->fc, AV_LOG_WARNING, "%i\n", partition->kag_size); + av_log(mxf->fc, AV_LOG_WARNING, "%"PRId32"\n", partition->kag_size); } return 0; @@ -548,11 +576,13 @@ static int mxf_read_partition_pack(void *arg, AVIOContext *pb, int tag, int size static int mxf_add_metadata_set(MXFContext *mxf, void *metadata_set) { - if (mxf->metadata_sets_count+1 >= UINT_MAX / sizeof(*mxf->metadata_sets)) - return AVERROR(ENOMEM); - mxf->metadata_sets = av_realloc(mxf->metadata_sets, (mxf->metadata_sets_count + 1) * sizeof(*mxf->metadata_sets)); - if (!mxf->metadata_sets) - return AVERROR(ENOMEM); + int err; + + if ((err = av_reallocp_array(&mxf->metadata_sets, mxf->metadata_sets_count + 1, + sizeof(*mxf->metadata_sets))) < 0) { + mxf->metadata_sets_count = 0; + return err; + } mxf->metadata_sets[mxf->metadata_sets_count] = metadata_set; mxf->metadata_sets_count++; return 0; @@ -636,9 +666,9 @@ static int mxf_read_track(void *arg, AVIOContext *pb, int tag, int size, UID uid case 0x4804: avio_read(pb, track->track_number, 4); break; - case 0x4B01: - track->edit_rate.den = avio_rb32(pb); + case 0x4b01: track->edit_rate.num = avio_rb32(pb); + track->edit_rate.den = avio_rb32(pb); break; case 0x4803: avio_read(pb, track->sequence_ref, 16); @@ -657,6 +687,9 @@ static int mxf_read_sequence(void *arg, AVIOContext *pb, int tag, int size, UID case 0x0201: avio_read(pb, sequence->data_definition_ul, 16); break; + case 0x4b02: + sequence->origin = avio_r8(pb); + break; case 0x1001: sequence->structural_components_count = avio_rb32(pb); if (sequence->structural_components_count >= UINT_MAX / sizeof(UID)) @@ -697,46 +730,16 @@ static int mxf_read_source_package(void *arg, AVIOContext *pb, int tag, int size return 0; } -static int mxf_read_delta_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment) -{ - int i, length; - - segment->nb_delta_entries = avio_rb32(pb); - if (segment->nb_delta_entries < 1 || - segment->nb_delta_entries > INT_MAX >> av_log2(sizeof(*segment->slice))) - return AVERROR(ENOMEM); - - length = avio_rb32(pb); - - segment->slice = av_mallocz(segment->nb_delta_entries * - sizeof(*segment->slice)); - if (!segment->slice) - return AVERROR(ENOMEM); - segment->element_delta = av_mallocz(segment->nb_delta_entries * - sizeof(*segment->element_delta)); - if (!segment->element_delta) { - av_freep(&segment->slice); - return AVERROR(ENOMEM); - } - - for (i = 0; i < segment->nb_delta_entries; i++) { - avio_r8(pb); /* PosTableIndex */ - segment->slice[i] = avio_r8(pb); - segment->element_delta[i] = avio_rb32(pb); - } - return 0; -} - static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *segment) { - int i, j, length; + int i, length; segment->nb_index_entries = avio_rb32(pb); if (!segment->nb_index_entries) return 0; else if (segment->nb_index_entries < 0 || segment->nb_index_entries > - (INT_MAX >> av_log2(sizeof(*segment->stream_offset_entries)))) + (INT_MAX / sizeof(*segment->stream_offset_entries))) return AVERROR(ENOMEM); length = avio_rb32(pb); @@ -747,41 +750,23 @@ static int mxf_read_index_entry_array(AVIOContext *pb, MXFIndexTableSegment *seg sizeof(*segment->flag_entries)); segment->stream_offset_entries = av_mallocz(segment->nb_index_entries * sizeof(*segment->stream_offset_entries)); - segment->slice_offset_entries = av_mallocz(segment->nb_index_entries * - sizeof(*segment->slice_offset_entries)); - if (!segment->flag_entries || !segment->stream_offset_entries || - !segment->slice_offset_entries || !segment->temporal_offset_entries) - goto errmem; + if (!segment->flag_entries || !segment->stream_offset_entries || + !segment->temporal_offset_entries) { + av_freep(&segment->flag_entries); + av_freep(&segment->stream_offset_entries); + av_freep(&segment->temporal_offset_entries); + return AVERROR(ENOMEM); + } for (i = 0; i < segment->nb_index_entries; i++) { segment->temporal_offset_entries[i] = avio_r8(pb); avio_r8(pb); /* KeyFrameOffset */ segment->flag_entries[i] = avio_r8(pb); segment->stream_offset_entries[i] = avio_rb64(pb); - if (segment->slice_count) { - segment->slice_offset_entries[i] = av_mallocz(segment->slice_count * - sizeof(**segment->slice_offset_entries)); - if (!segment->slice_offset_entries[i]) - goto errmem; - - for (j = 0; j < segment->slice_count; j++) - segment->slice_offset_entries[i][j] = avio_rb32(pb); - } - - avio_skip(pb, length - 11 - 4 * segment->slice_count); + avio_skip(pb, length - 11); } return 0; -errmem: - if (segment->slice_offset_entries && segment->slice_count) { - for (i = 0; i < segment->nb_index_entries; i++) - av_free(segment->slice_offset_entries[i]); - } - av_freep(&segment->flag_entries); - av_freep(&segment->stream_offset_entries); - av_freep(&segment->slice_offset_entries); - av_freep(&segment->temporal_offset_entries); - return AVERROR(ENOMEM); } static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) @@ -800,13 +785,6 @@ static int mxf_read_index_table_segment(void *arg, AVIOContext *pb, int tag, int segment->body_sid = avio_rb32(pb); av_dlog(NULL, "BodySID %d\n", segment->body_sid); break; - case 0x3F08: - segment->slice_count = avio_r8(pb); - av_dlog(NULL, "SliceCount %d\n", segment->slice_count); - break; - case 0x3F09: - av_dlog(NULL, "DeltaEntryArray found\n"); - return mxf_read_delta_entry_array(pb, segment); case 0x3F0A: av_dlog(NULL, "IndexEntryArray found\n"); return mxf_read_index_entry_array(pb, segment); @@ -838,7 +816,7 @@ static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor) value = avio_r8(pb); av_dlog(NULL, "pixel layout: code %#x\n", code); - if (ofs < 16) { + if (ofs <= 14) { layout[ofs++] = code; layout[ofs++] = value; } @@ -850,6 +828,7 @@ static void mxf_read_pixel_layout(AVIOContext *pb, MXFDescriptor *descriptor) static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int size, UID uid, int64_t klv_offset) { MXFDescriptor *descriptor = arg; + descriptor->pix_fmt = AV_PIX_FMT_NONE; switch(tag) { case 0x3F01: descriptor->sub_descriptors_count = avio_rb32(pb); @@ -876,10 +855,25 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int case 0x3202: descriptor->height = avio_rb32(pb); break; + case 0x320C: + descriptor->frame_layout = avio_r8(pb); + break; case 0x320E: descriptor->aspect_ratio.num = avio_rb32(pb); descriptor->aspect_ratio.den = avio_rb32(pb); break; + case 0x3212: + descriptor->field_dominance = avio_r8(pb); + break; + case 0x3301: + descriptor->component_depth = avio_rb32(pb); + break; + case 0x3302: + descriptor->horiz_subsampling = avio_rb32(pb); + break; + case 0x3308: + descriptor->vert_subsampling = avio_rb32(pb); + break; case 0x3D03: descriptor->sample_rate.num = avio_rb32(pb); descriptor->sample_rate.den = avio_rb32(pb); @@ -899,6 +893,8 @@ static int mxf_read_generic_descriptor(void *arg, AVIOContext *pb, int tag, int default: /* Private uid used by SONY C0023S01.mxf */ if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) { + av_free(descriptor->extradata); + descriptor->extradata_size = 0; descriptor->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); if (!descriptor->extradata) return AVERROR(ENOMEM); @@ -949,16 +945,44 @@ static void *mxf_resolve_strong_ref(MXFContext *mxf, UID *strong_ref, enum MXFMe return NULL; } -static const MXFCodecUL mxf_essence_container_uls[] = { +static const MXFCodecUL mxf_picture_essence_container_uls[] = { // video essence container uls - { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x60,0x01 }, 14, CODEC_ID_MPEG2VIDEO }, /* MPEG-ES Frame wrapped */ - { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, CODEC_ID_DVVIDEO }, /* DV 625 25mbps */ + { { 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 */ + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x02,0x41,0x01 }, 14, AV_CODEC_ID_DVVIDEO }, /* DV 625 25mbps */ + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x01,0x0d,0x01,0x03,0x01,0x02,0x05,0x00,0x00 }, 14, AV_CODEC_ID_RAWVIDEO }, /* Uncompressed Picture */ + { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, +}; + +/* EC ULs for intra-only formats */ +static const MXFCodecUL mxf_intra_only_essence_container_uls[] = { + { { 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 */ + { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, +}; + +/* intra-only PictureEssenceCoding ULs, where no corresponding EC UL exists */ +static const MXFCodecUL mxf_intra_only_picture_essence_coding_uls[] = { + { { 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 */ + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x07,0x04,0x01,0x02,0x02,0x03,0x01,0x01,0x00 }, 14, AV_CODEC_ID_JPEG2000 }, /* JPEG2000 Codestream */ + { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, +}; + +static const MXFCodecUL mxf_sound_essence_container_uls[] = { // sound essence container uls - { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x06,0x01,0x00 }, 14, CODEC_ID_PCM_S16LE }, /* BWF Frame wrapped */ - { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x02,0x0D,0x01,0x03,0x01,0x02,0x04,0x40,0x01 }, 14, CODEC_ID_MP2 }, /* MPEG-ES Frame wrapped, 0x40 ??? stream id */ - { { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x03,0x01,0x02,0x01,0x01,0x01 }, 14, CODEC_ID_PCM_S16LE }, /* D-10 Mapping 50Mbps PAL Extended Template */ - { { 0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0xFF,0x4B,0x46,0x41,0x41,0x00,0x0D,0x4D,0x4F }, 14, CODEC_ID_PCM_S16LE }, /* 0001GL00.MXF.A1.mxf_opatom.mxf */ - { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, CODEC_ID_NONE }, + { { 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 */ + { { 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 */ + { { 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 */ + { { 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 */ + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x03,0x04,0x02,0x02,0x02,0x03,0x03,0x01,0x00 }, 14, AV_CODEC_ID_AAC }, /* MPEG2 AAC ADTS (legacy) */ + { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, 0, AV_CODEC_ID_NONE }, +}; + +static const MXFCodecUL mxf_data_essence_container_uls[] = { + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, 0 }, + { { 0x06,0x0e,0x2b,0x34,0x04,0x01,0x01,0x09,0x0d,0x01,0x03,0x01,0x02,0x0e,0x00,0x00 }, 16, AV_CODEC_ID_NONE }, +}; + +static const char* mxf_data_essence_descriptor[] = { + "vbi_vanc_smpte_436M", }; static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segments, MXFIndexTableSegment ***sorted_segments) @@ -972,9 +996,12 @@ static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segment if (mxf->metadata_sets[i]->type == IndexTableSegment) nb_segments++; + if (!nb_segments) + return AVERROR_INVALIDDATA; + *sorted_segments = av_mallocz(nb_segments * sizeof(**sorted_segments)); unsorted_segments = av_mallocz(nb_segments * sizeof(*unsorted_segments)); - if (!sorted_segments || !unsorted_segments) { + if (!*sorted_segments || !unsorted_segments) { av_freep(sorted_segments); av_free(unsorted_segments); return AVERROR(ENOMEM); @@ -989,19 +1016,23 @@ static int mxf_get_sorted_table_segments(MXFContext *mxf, int *nb_sorted_segment /* sort segments by {BodySID, IndexSID, IndexStartPosition}, remove duplicates while we're at it */ for (i = 0; i < nb_segments; i++) { int best = -1, best_body_sid = -1, best_index_sid = -1, best_index_start = -1; + uint64_t best_index_duration = 0; for (j = 0; j < nb_segments; j++) { MXFIndexTableSegment *s = unsorted_segments[j]; /* Require larger BosySID, IndexSID or IndexStartPosition then the previous entry. This removes duplicates. * We want the smallest values for the keys than what we currently have, unless this is the first such entry this time around. + * If we come across an entry with the same IndexStartPosition but larger IndexDuration, then we'll prefer it over the one we currently have. */ if ((i == 0 || s->body_sid > last_body_sid || s->index_sid > last_index_sid || s->index_start_position > last_index_start) && - (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start)) { + (best == -1 || s->body_sid < best_body_sid || s->index_sid < best_index_sid || s->index_start_position < best_index_start || + (s->index_start_position == best_index_start && s->index_duration > best_index_duration))) { best = j; best_body_sid = s->body_sid; best_index_sid = s->index_sid; best_index_start = s->index_start_position; + best_index_duration = s->index_duration; } } @@ -1042,117 +1073,296 @@ static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t of offset -= p->essence_length; } - av_log(mxf->fc, AV_LOG_ERROR, "failed to find absolute offset of %lx in BodySID %i - partial file?\n", + av_log(mxf->fc, AV_LOG_ERROR, + "failed to find absolute offset of %"PRIX64" in BodySID %i - partial file?\n", offset_in, body_sid); return AVERROR_INVALIDDATA; } -static int mxf_parse_index(MXFContext *mxf, int track_id, AVStream *st) +/** + * Returns the end position of the essence container with given BodySID, or zero if unknown + */ +static int64_t mxf_essence_container_end(MXFContext *mxf, int body_sid) { - int64_t accumulated_offset = 0; - int j, k, ret, nb_sorted_segments; - MXFIndexTableSegment **sorted_segments; - int n_delta = track_id - 1; /* TrackID = 1-based stream index */ + int x; + int64_t ret = 0; - if (track_id < 1) { - av_log(mxf->fc, AV_LOG_ERROR, "TrackID not positive: %i\n", track_id); - return AVERROR_INVALIDDATA; + for (x = 0; x < mxf->partitions_count; x++) { + MXFPartition *p = &mxf->partitions[x]; + + if (p->body_sid != body_sid) + continue; + + if (!p->essence_length) + return 0; + + ret = p->essence_offset + p->essence_length; } - if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments))) - return ret; + return ret; +} - for (j = 0; j < nb_sorted_segments; j++) { - int duration, sample_duration = 1, last_sample_size = 0; - int64_t segment_size; - MXFIndexTableSegment *tableseg = sorted_segments[j]; +/* EditUnit -> absolute offset */ +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) +{ + int i; + int64_t offset_temp = 0; - /* reset accumulated_offset on BodySID change */ - if (j > 0 && tableseg->body_sid != sorted_segments[j-1]->body_sid) - accumulated_offset = 0; + for (i = 0; i < index_table->nb_segments; i++) { + MXFIndexTableSegment *s = index_table->segments[i]; - if (n_delta >= tableseg->nb_delta_entries && st->index != 0) - continue; - duration = tableseg->index_duration > 0 ? tableseg->index_duration : - st->duration - st->nb_index_entries; - segment_size = tableseg->edit_unit_byte_count * duration; - /* check small EditUnitByteCount for audio */ - if (tableseg->edit_unit_byte_count && tableseg->edit_unit_byte_count < 32 - && !tableseg->index_duration) { - /* duration might be prime relative to the new sample_duration, - * which means we need to handle the last frame differently */ - sample_duration = 8192; - last_sample_size = (duration % sample_duration) * tableseg->edit_unit_byte_count; - tableseg->edit_unit_byte_count *= sample_duration; - duration /= sample_duration; - if (last_sample_size) duration++; - } + edit_unit = FFMAX(edit_unit, s->index_start_position); /* clamp if trying to seek before start */ - for (k = 0; k < duration; k++) { - int64_t pos; - int size, flags = 0; - - if (k < tableseg->nb_index_entries) { - pos = tableseg->stream_offset_entries[k]; - if (n_delta < tableseg->nb_delta_entries) { - if (n_delta < tableseg->nb_delta_entries - 1) { - size = - tableseg->slice_offset_entries[k][tableseg->slice[n_delta+1]-1] + - tableseg->element_delta[n_delta+1] - - tableseg->element_delta[n_delta]; - if (tableseg->slice[n_delta] > 0) - size -= tableseg->slice_offset_entries[k][tableseg->slice[n_delta]-1]; - } else if (k < duration - 1) { - size = tableseg->stream_offset_entries[k+1] - - tableseg->stream_offset_entries[k] - - tableseg->slice_offset_entries[k][tableseg->slice[tableseg->nb_delta_entries-1]-1] - - tableseg->element_delta[tableseg->nb_delta_entries-1]; - } else - size = 0; - if (tableseg->slice[n_delta] > 0) - pos += tableseg->slice_offset_entries[k][tableseg->slice[n_delta]-1]; - pos += tableseg->element_delta[n_delta]; - } else - size = 0; - flags = !(tableseg->flag_entries[k] & 0x30) ? AVINDEX_KEYFRAME : 0; - } else { - pos = (int64_t)k * tableseg->edit_unit_byte_count + accumulated_offset; - if (n_delta < tableseg->nb_delta_entries - 1) - size = tableseg->element_delta[n_delta+1] - tableseg->element_delta[n_delta]; - else { - /* use smaller size for last sample if we should */ - if (last_sample_size && k == duration - 1) - size = last_sample_size; - else - size = tableseg->edit_unit_byte_count; - if (tableseg->nb_delta_entries) - size -= tableseg->element_delta[tableseg->nb_delta_entries-1]; + if (edit_unit < s->index_start_position + s->index_duration) { + int64_t index = edit_unit - s->index_start_position; + + if (s->edit_unit_byte_count) + offset_temp += s->edit_unit_byte_count * index; + else if (s->nb_index_entries) { + if (s->nb_index_entries == 2 * s->index_duration + 1) + index *= 2; /* Avid index */ + + if (index < 0 || index >= s->nb_index_entries) { + av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" IndexEntryArray too small\n", + index_table->index_sid, s->index_start_position); + return AVERROR_INVALIDDATA; } - if (n_delta < tableseg->nb_delta_entries) - pos += tableseg->element_delta[n_delta]; - flags = AVINDEX_KEYFRAME; + + offset_temp = s->stream_offset_entries[index]; + } else { + av_log(mxf->fc, AV_LOG_ERROR, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n", + index_table->index_sid, s->index_start_position); + return AVERROR_INVALIDDATA; } - if (mxf_absolute_bodysid_offset(mxf, tableseg->body_sid, pos, &pos) < 0) { - /* probably partial file - no point going further for this stream */ + if (edit_unit_out) + *edit_unit_out = edit_unit; + + return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out); + } else { + /* EditUnitByteCount == 0 for VBR indexes, which is fine since they use explicit StreamOffsets */ + offset_temp += s->edit_unit_byte_count * s->index_duration; + } + } + + if (nag) + 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); + + return AVERROR_INVALIDDATA; +} + +static int mxf_compute_ptses_fake_index(MXFContext *mxf, MXFIndexTable *index_table) +{ + int i, j, x; + int8_t max_temporal_offset = -128; + + /* first compute how many entries we have */ + for (i = 0; i < index_table->nb_segments; i++) { + MXFIndexTableSegment *s = index_table->segments[i]; + + if (!s->nb_index_entries) { + index_table->nb_ptses = 0; + return 0; /* no TemporalOffsets */ + } + + index_table->nb_ptses += s->index_duration; + } + + /* paranoid check */ + if (index_table->nb_ptses <= 0) + return 0; + + if (index_table->nb_ptses > INT_MAX / sizeof(AVIndexEntry)) + return AVERROR(ENOMEM); + + index_table->ptses = av_mallocz(index_table->nb_ptses * + sizeof(int64_t)); + index_table->fake_index = av_mallocz(index_table->nb_ptses * + sizeof(AVIndexEntry)); + if (!index_table->ptses || !index_table->fake_index) { + av_freep(&index_table->ptses); + return AVERROR(ENOMEM); + } + + /* we may have a few bad TemporalOffsets + * make sure the corresponding PTSes don't have the bogus value 0 */ + for (x = 0; x < index_table->nb_ptses; x++) + index_table->ptses[x] = AV_NOPTS_VALUE; + + /** + * We have this: + * + * x TemporalOffset + * 0: 0 + * 1: 1 + * 2: 1 + * 3: -2 + * 4: 1 + * 5: 1 + * 6: -2 + * + * We want to transform it into this: + * + * x DTS PTS + * 0: -1 0 + * 1: 0 3 + * 2: 1 1 + * 3: 2 2 + * 4: 3 6 + * 5: 4 4 + * 6: 5 5 + * + * We do this by bucket sorting x by x+TemporalOffset[x] into mxf->ptses, + * then settings mxf->first_dts = -max(TemporalOffset[x]). + * The latter makes DTS <= PTS. + */ + for (i = x = 0; i < index_table->nb_segments; i++) { + MXFIndexTableSegment *s = index_table->segments[i]; + int index_delta = 1; + int n = s->nb_index_entries; + + if (s->nb_index_entries == 2 * s->index_duration + 1) { + index_delta = 2; /* Avid index */ + /* ignore the last entry - it's the size of the essence container */ + n--; + } + + for (j = 0; j < n; j += index_delta, x++) { + int offset = s->temporal_offset_entries[j] / index_delta; + int index = x + offset; + + if (x >= index_table->nb_ptses) { + av_log(mxf->fc, AV_LOG_ERROR, + "x >= nb_ptses - IndexEntryCount %i < IndexDuration %"PRId64"?\n", + s->nb_index_entries, s->index_duration); break; } - av_dlog(mxf->fc, "Stream %d IndexEntry %d TrackID %d Offset %"PRIx64" Timestamp %"PRId64"\n", - st->index, st->nb_index_entries, track_id, pos, sample_duration * st->nb_index_entries); + index_table->fake_index[x].timestamp = x; + index_table->fake_index[x].flags = !(s->flag_entries[j] & 0x30) ? AVINDEX_KEYFRAME : 0; - if ((ret = av_add_index_entry(st, pos, sample_duration * st->nb_index_entries, size, 0, flags)) < 0) - return ret; + if (index < 0 || index >= index_table->nb_ptses) { + av_log(mxf->fc, AV_LOG_ERROR, + "index entry %i + TemporalOffset %i = %i, which is out of bounds\n", + x, offset, index); + continue; + } + + index_table->ptses[index] = x; + max_temporal_offset = FFMAX(max_temporal_offset, offset); } - accumulated_offset += segment_size; } - av_free(sorted_segments); + index_table->first_dts = -max_temporal_offset; return 0; } +/** + * Sorts and collects index table segments into index tables. + * Also computes PTSes if possible. + */ +static int mxf_compute_index_tables(MXFContext *mxf) +{ + int i, j, k, ret, nb_sorted_segments; + MXFIndexTableSegment **sorted_segments = NULL; + + if ((ret = mxf_get_sorted_table_segments(mxf, &nb_sorted_segments, &sorted_segments)) || + nb_sorted_segments <= 0) { + av_log(mxf->fc, AV_LOG_WARNING, "broken or empty index\n"); + return 0; + } + + /* sanity check and count unique BodySIDs/IndexSIDs */ + for (i = 0; i < nb_sorted_segments; i++) { + if (i == 0 || sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) + mxf->nb_index_tables++; + else if (sorted_segments[i-1]->body_sid != sorted_segments[i]->body_sid) { + av_log(mxf->fc, AV_LOG_ERROR, "found inconsistent BodySID\n"); + ret = AVERROR_INVALIDDATA; + goto finish_decoding_index; + } + } + + mxf->index_tables = av_mallocz_array(mxf->nb_index_tables, + sizeof(*mxf->index_tables)); + if (!mxf->index_tables) { + av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate index tables\n"); + ret = AVERROR(ENOMEM); + goto finish_decoding_index; + } + + /* distribute sorted segments to index tables */ + for (i = j = 0; i < nb_sorted_segments; i++) { + if (i != 0 && sorted_segments[i-1]->index_sid != sorted_segments[i]->index_sid) { + /* next IndexSID */ + j++; + } + + mxf->index_tables[j].nb_segments++; + } + + for (i = j = 0; j < mxf->nb_index_tables; i += mxf->index_tables[j++].nb_segments) { + MXFIndexTable *t = &mxf->index_tables[j]; + + t->segments = av_mallocz_array(t->nb_segments, + sizeof(*t->segments)); + + if (!t->segments) { + av_log(mxf->fc, AV_LOG_ERROR, "failed to allocate IndexTableSegment" + " pointer array\n"); + ret = AVERROR(ENOMEM); + goto finish_decoding_index; + } + + if (sorted_segments[i]->index_start_position) + av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i starts at EditUnit %"PRId64" - seeking may not work as expected\n", + sorted_segments[i]->index_sid, sorted_segments[i]->index_start_position); + + memcpy(t->segments, &sorted_segments[i], t->nb_segments * sizeof(MXFIndexTableSegment*)); + t->index_sid = sorted_segments[i]->index_sid; + t->body_sid = sorted_segments[i]->body_sid; + + if ((ret = mxf_compute_ptses_fake_index(mxf, t)) < 0) + goto finish_decoding_index; + + /* fix zero IndexDurations */ + for (k = 0; k < t->nb_segments; k++) { + if (t->segments[k]->index_duration) + continue; + + if (t->nb_segments > 1) + av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has zero IndexDuration and there's more than one segment\n", + t->index_sid, k); + + if (mxf->fc->nb_streams <= 0) { + av_log(mxf->fc, AV_LOG_WARNING, "no streams?\n"); + break; + } + + /* assume the first stream's duration is reasonable + * leave index_duration = 0 on further segments in case we have any (unlikely) + */ + t->segments[k]->index_duration = mxf->fc->streams[0]->duration; + break; + } + } + + ret = 0; +finish_decoding_index: + av_free(sorted_segments); + return ret; +} + +static int mxf_is_intra_only(MXFDescriptor *d) +{ + return mxf_get_codec_ul(mxf_intra_only_essence_container_uls, + &d->essence_container_ul)->id != AV_CODEC_ID_NONE || + mxf_get_codec_ul(mxf_intra_only_picture_essence_coding_uls, + &d->essence_codec_ul)->id != AV_CODEC_ID_NONE; +} + static int mxf_parse_structural_metadata(MXFContext *mxf) { MXFPackage *material_package = NULL; @@ -1180,6 +1390,7 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) UID *essence_container_ul = NULL; const MXFCodecUL *codec_ul = NULL; const MXFCodecUL *container_ul = NULL; + const MXFCodecUL *pix_fmt_ul = NULL; AVStream *st; if (!(material_track = mxf_resolve_strong_ref(mxf, &material_package->tracks_refs[i], Track))) { @@ -1215,7 +1426,8 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) for (k = 0; k < source_package->tracks_count; k++) { if (!(temp_track = mxf_resolve_strong_ref(mxf, &source_package->tracks_refs[k], Track))) { av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track strong ref\n"); - return AVERROR_INVALIDDATA; + ret = AVERROR_INVALIDDATA; + goto fail_and_free; } if (temp_track->track_id == component->source_track_id) { source_track = temp_track; @@ -1227,12 +1439,13 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) break; } } - if (!source_track) + if (!source_track || !component) continue; if (!(source_track->sequence = mxf_resolve_strong_ref(mxf, &source_track->sequence_ref, Sequence))) { av_log(mxf->fc, AV_LOG_ERROR, "could not resolve source track sequence strong ref\n"); - return AVERROR_INVALIDDATA; + ret = AVERROR_INVALIDDATA; + goto fail_and_free; } /* 0001GL00.MXF.A1.mxf_opatom.mxf has the same SourcePackageID as 0001GL.MXF.V1.mxf_opatom.mxf @@ -1245,15 +1458,29 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) st = avformat_new_stream(mxf->fc, NULL); if (!st) { av_log(mxf->fc, AV_LOG_ERROR, "could not allocate stream\n"); - return AVERROR(ENOMEM); + ret = AVERROR(ENOMEM); + goto fail_and_free; } st->id = source_track->track_id; st->priv_data = source_track; - st->duration = component->duration; + source_track->original_duration = st->duration = component->duration; if (st->duration == -1) st->duration = AV_NOPTS_VALUE; st->start_time = component->start_position; - avpriv_set_pts_info(st, 64, material_track->edit_rate.num, material_track->edit_rate.den); + if (material_track->edit_rate.num <= 0 || + material_track->edit_rate.den <= 0) { + av_log(mxf->fc, AV_LOG_WARNING, + "Invalid edit rate (%d/%d) found on stream #%d, " + "defaulting to 25/1\n", + material_track->edit_rate.num, + material_track->edit_rate.den, st->index); + material_track->edit_rate = (AVRational){25, 1}; + } + avpriv_set_pts_info(st, 64, material_track->edit_rate.den, material_track->edit_rate.num); + + /* ensure SourceTrack EditRate == MaterialTrack EditRate since only + * the former is accessible via st->priv_data */ + source_track->edit_rate = material_track->edit_rate; PRINT_KEY(mxf->fc, "data definition ul", source_track->sequence->data_definition_ul); codec_ul = mxf_get_codec_ul(ff_mxf_data_definition_uls, &source_track->sequence->data_definition_ul); @@ -1296,83 +1523,314 @@ static int mxf_parse_structural_metadata(MXFContext *mxf) } } } + /* TODO: drop PictureEssenceCoding and SoundEssenceCompression, only check EssenceContainer */ codec_ul = mxf_get_codec_ul(ff_mxf_codec_uls, &descriptor->essence_codec_ul); st->codec->codec_id = codec_ul->id; - if (descriptor->extradata) { - st->codec->extradata = descriptor->extradata; - st->codec->extradata_size = descriptor->extradata_size; - } + if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { - container_ul = mxf_get_codec_ul(mxf_essence_container_uls, essence_container_ul); - if (st->codec->codec_id == CODEC_ID_NONE) + source_track->intra_only = mxf_is_intra_only(descriptor); + container_ul = mxf_get_codec_ul(mxf_picture_essence_container_uls, essence_container_ul); + if (st->codec->codec_id == AV_CODEC_ID_NONE) st->codec->codec_id = container_ul->id; st->codec->width = descriptor->width; + /* Field height, not frame height */ st->codec->height = descriptor->height; - if (st->codec->codec_id == CODEC_ID_RAWVIDEO) + switch (descriptor->frame_layout) { + case SegmentedFrame: + /* This one is a weird layout I don't fully understand. */ + av_log(mxf->fc, AV_LOG_INFO, + "SegmentedFrame layout isn't currently supported\n"); + break; + case FullFrame: + st->codec->field_order = AV_FIELD_PROGRESSIVE; + break; + case OneField: + /* Every other line is stored and needs to be duplicated. */ + av_log(mxf->fc, AV_LOG_INFO, + "OneField frame layout isn't currently supported\n"); + break; + /* The correct thing to do here is fall through, but by + * breaking we might be able to decode some streams at half + * the vertical resolution, rather than not al all. + * It's also for compatibility with the old behavior. */ + case SeparateFields: + case MixedFields: + switch (descriptor->field_dominance) { + case MXF_TFF: + st->codec->field_order = AV_FIELD_TT; + break; + case MXF_BFF: + st->codec->field_order = AV_FIELD_BB; + break; + default: + avpriv_request_sample(mxf->fc, + "Field dominance %d support", + descriptor->field_dominance); + break; + } + /* Turn field height into frame height. */ + st->codec->height *= 2; + break; + default: + av_log(mxf->fc, AV_LOG_INFO, + "Unknown frame layout type: %d\n", + descriptor->frame_layout); + } + if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO) { st->codec->pix_fmt = descriptor->pix_fmt; + if (st->codec->pix_fmt == AV_PIX_FMT_NONE) { + pix_fmt_ul = mxf_get_codec_ul(ff_mxf_pixel_format_uls, + &descriptor->essence_codec_ul); + st->codec->pix_fmt = pix_fmt_ul->id; + if (st->codec->pix_fmt == AV_PIX_FMT_NONE) { + /* support files created before RP224v10 by defaulting to UYVY422 + if subsampling is 4:2:2 and component depth is 8-bit */ + if (descriptor->horiz_subsampling == 2 && + descriptor->vert_subsampling == 1 && + descriptor->component_depth == 8) { + st->codec->pix_fmt = AV_PIX_FMT_UYVY422; + } + } + } + } st->need_parsing = AVSTREAM_PARSE_HEADERS; + if (material_track->sequence->origin) { + char material_origin[3]; + snprintf(material_origin, sizeof(material_origin), "%d", material_track->sequence->origin); + av_dict_set(&st->metadata, "material_track_origin", material_origin, 0); + } + if (source_track->sequence->origin) { + char source_origin[3]; + snprintf(source_origin, sizeof(source_origin), "%d", source_track->sequence->origin); + av_dict_set(&st->metadata, "source_track_origin", source_origin, 0); + } } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { - container_ul = mxf_get_codec_ul(mxf_essence_container_uls, essence_container_ul); - if (st->codec->codec_id == CODEC_ID_NONE) + container_ul = mxf_get_codec_ul(mxf_sound_essence_container_uls, essence_container_ul); + if (st->codec->codec_id == AV_CODEC_ID_NONE) st->codec->codec_id = container_ul->id; st->codec->channels = descriptor->channels; st->codec->bits_per_coded_sample = descriptor->bits_per_sample; - st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den; - /* TODO: implement CODEC_ID_RAWAUDIO */ - if (st->codec->codec_id == CODEC_ID_PCM_S16LE) { + + if (descriptor->sample_rate.den > 0) { + st->codec->sample_rate = descriptor->sample_rate.num / descriptor->sample_rate.den; + avpriv_set_pts_info(st, 64, descriptor->sample_rate.den, descriptor->sample_rate.num); + } else { + av_log(mxf->fc, AV_LOG_WARNING, "invalid sample rate (%d/%d) " + "found for stream #%d, time base forced to 1/48000\n", + descriptor->sample_rate.num, descriptor->sample_rate.den, + st->index); + avpriv_set_pts_info(st, 64, 1, 48000); + } + + /* if duration is set, rescale it from EditRate to SampleRate */ + if (st->duration != AV_NOPTS_VALUE) + st->duration = av_rescale_q(st->duration, + av_inv_q(material_track->edit_rate), + st->time_base); + + /* TODO: implement AV_CODEC_ID_RAWAUDIO */ + if (st->codec->codec_id == AV_CODEC_ID_PCM_S16LE) { if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24) - st->codec->codec_id = CODEC_ID_PCM_S24LE; + st->codec->codec_id = AV_CODEC_ID_PCM_S24LE; else if (descriptor->bits_per_sample == 32) - st->codec->codec_id = CODEC_ID_PCM_S32LE; - } else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) { + st->codec->codec_id = AV_CODEC_ID_PCM_S32LE; + } else if (st->codec->codec_id == AV_CODEC_ID_PCM_S16BE) { if (descriptor->bits_per_sample > 16 && descriptor->bits_per_sample <= 24) - st->codec->codec_id = CODEC_ID_PCM_S24BE; + st->codec->codec_id = AV_CODEC_ID_PCM_S24BE; else if (descriptor->bits_per_sample == 32) - st->codec->codec_id = CODEC_ID_PCM_S32BE; - } else if (st->codec->codec_id == CODEC_ID_MP2) { + st->codec->codec_id = AV_CODEC_ID_PCM_S32BE; + } else if (st->codec->codec_id == AV_CODEC_ID_MP2) { st->need_parsing = AVSTREAM_PARSE_FULL; } + } else if (st->codec->codec_type == AVMEDIA_TYPE_DATA) { + int codec_id = mxf_get_codec_ul(mxf_data_essence_container_uls, + essence_container_ul)->id; + if (codec_id >= 0 && + codec_id < FF_ARRAY_ELEMS(mxf_data_essence_descriptor)) { + av_dict_set(&st->metadata, "data_type", + mxf_data_essence_descriptor[codec_id], 0); + } + } + if (descriptor->extradata) { + st->codec->extradata = av_mallocz(descriptor->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); + if (st->codec->extradata) { + memcpy(st->codec->extradata, descriptor->extradata, descriptor->extradata_size); + st->codec->extradata_size = descriptor->extradata_size; + } + } else if (st->codec->codec_id == AV_CODEC_ID_H264) { + ret = ff_generate_avci_extradata(st); + if (ret < 0) + return ret; } if (st->codec->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) { - av_log(mxf->fc, AV_LOG_WARNING, "only frame wrapped mappings are correctly supported\n"); - st->need_parsing = AVSTREAM_PARSE_FULL; + /* TODO: decode timestamps */ + st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS; + } + } + + ret = 0; +fail_and_free: + return ret; +} + +static int mxf_read_utf16_string(AVIOContext *pb, int size, char** str) +{ + int ret; + size_t buf_size; + + if (size < 0) + return AVERROR(EINVAL); + + buf_size = size + size / 2 + 1; + *str = av_malloc(buf_size); + if (!*str) + return AVERROR(ENOMEM); + + if ((ret = avio_get_str16be(pb, size, *str, buf_size)) < 0) { + av_freep(str); + return ret; + } + + return ret; +} + +static int mxf_uid_to_str(UID uid, char **str) +{ + int i; + char *p; + p = *str = av_mallocz(sizeof(UID) * 2 + 4 + 1); + if (!p) + return AVERROR(ENOMEM); + for (i = 0; i < sizeof(UID); i++) { + snprintf(p, 2 + 1, "%.2x", uid[i]); + p += 2; + if (i == 3 || i == 5 || i == 7 || i == 9) { + snprintf(p, 1 + 1, "-"); + p++; } + } + return 0; +} - if ((ret = mxf_parse_index(mxf, material_track->track_id, st))) - return ret; +static int mxf_timestamp_to_str(uint64_t timestamp, char **str) +{ + struct tm time = { 0 }; + time.tm_year = (timestamp >> 48) - 1900; + time.tm_mon = (timestamp >> 40 & 0xFF) - 1; + time.tm_mday = (timestamp >> 32 & 0xFF); + time.tm_hour = (timestamp >> 24 & 0xFF); + time.tm_min = (timestamp >> 16 & 0xFF); + time.tm_sec = (timestamp >> 8 & 0xFF); + + /* msvcrt versions of strftime calls the invalid parameter handler + * (aborting the process if one isn't set) if the parameters are out + * of range. */ + time.tm_mon = av_clip(time.tm_mon, 0, 11); + time.tm_mday = av_clip(time.tm_mday, 1, 31); + time.tm_hour = av_clip(time.tm_hour, 0, 23); + time.tm_min = av_clip(time.tm_min, 0, 59); + time.tm_sec = av_clip(time.tm_sec, 0, 59); + + *str = av_mallocz(32); + if (!*str) + return AVERROR(ENOMEM); + if (!strftime(*str, 32, "%Y-%m-%d %H:%M:%S", &time)) + str[0] = '\0'; + + return 0; +} + +#define SET_STR_METADATA(pb, name, str) do { \ + if ((ret = mxf_read_utf16_string(pb, size, &str)) < 0) \ + return ret; \ + av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ +} while (0) + +#define SET_UID_METADATA(pb, name, var, str) do { \ + avio_read(pb, var, 16); \ + if ((ret = mxf_uid_to_str(var, &str)) < 0) \ + return ret; \ + av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ +} while (0) + +#define SET_TS_METADATA(pb, name, var, str) do { \ + var = avio_rb64(pb); \ + if ((ret = mxf_timestamp_to_str(var, &str)) < 0) \ + return ret; \ + av_dict_set(&s->metadata, name, str, AV_DICT_DONT_STRDUP_VAL); \ +} while (0) + +static int mxf_read_identification_metadata(void *arg, AVIOContext *pb, int tag, int size, UID _uid, int64_t klv_offset) +{ + MXFContext *mxf = arg; + AVFormatContext *s = mxf->fc; + int ret; + UID uid = { 0 }; + char *str = NULL; + uint64_t ts; + switch (tag) { + case 0x3C01: + SET_STR_METADATA(pb, "company_name", str); + break; + case 0x3C02: + SET_STR_METADATA(pb, "product_name", str); + break; + case 0x3C04: + SET_STR_METADATA(pb, "product_version", str); + break; + case 0x3C05: + SET_UID_METADATA(pb, "product_uid", uid, str); + break; + case 0x3C06: + SET_TS_METADATA(pb, "modification_date", ts, str); + break; + case 0x3C08: + SET_STR_METADATA(pb, "application_platform", str); + break; + case 0x3C09: + SET_UID_METADATA(pb, "generation_uid", uid, str); + break; + case 0x3C0A: + SET_UID_METADATA(pb, "uid", uid, str); + break; } return 0; } static const MXFMetadataReadTableEntry mxf_metadata_read_table[] = { - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor }, - { { 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 */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */ - { { 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 */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */ - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext }, - { { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x05,0x01,0x00 }, mxf_read_primer_pack }, +// { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x2f,0x00 }, mxf_read_preface_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x01,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x02,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x03,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x02,0x04,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x01,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x02,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x03,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x03,0x04,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x02,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x05,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }, mxf_read_partition_pack }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x30,0x00 }, mxf_read_identification_metadata }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x18,0x00 }, mxf_read_content_storage, 0, AnyType }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x37,0x00 }, mxf_read_source_package, sizeof(MXFPackage), SourcePackage }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x36,0x00 }, mxf_read_material_package, sizeof(MXFPackage), MaterialPackage }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x0F,0x00 }, mxf_read_sequence, sizeof(MXFSequence), Sequence }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x11,0x00 }, mxf_read_source_clip, sizeof(MXFStructuralComponent), SourceClip }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x44,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), MultipleDescriptor }, + { { 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 */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x28,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* CDCI */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x29,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* RGBA */ + { { 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 */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x48,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* Wave */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x47,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* AES3 */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2VideoDescriptor */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5c,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* VANC/VBI - SMPTE 436M */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x5e,0x00 }, mxf_read_generic_descriptor, sizeof(MXFDescriptor), Descriptor }, /* MPEG2AudioDescriptor */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3A,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Static Track */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x3B,0x00 }, mxf_read_track, sizeof(MXFTrack), Track }, /* Generic Track */ + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x04,0x01,0x02,0x02,0x00,0x00 }, mxf_read_cryptographic_context, sizeof(MXFCryptoContext), CryptoContext }, + { { 0x06,0x0e,0x2b,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 }, mxf_read_index_table_segment, sizeof(MXFIndexTableSegment), IndexTableSegment }, { { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, NULL, 0, AnyType }, }; @@ -1384,7 +1842,7 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF if (!ctx) return AVERROR(ENOMEM); - while (avio_tell(pb) + 4 < klv_end) { + while (avio_tell(pb) + 4 < klv_end && !pb->eof_reached) { int ret; int tag = avio_rb16(pb); int size = avio_rb16(pb); /* KLV specified by 0x53 */ @@ -1412,7 +1870,18 @@ static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadF else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) return ret; - avio_seek(pb, next, SEEK_SET); + /* Accept the 64k local set limit being exceeded (Avid). Don't accept + * it extending past the end of the KLV though (zzuf5.mxf). */ + if (avio_tell(pb) > klv_end) { + if (ctx_size) + av_free(ctx); + + av_log(mxf->fc, AV_LOG_ERROR, + "local tag %#04x extends past end of local set @ %#"PRIx64"\n", + tag, klv->offset); + return AVERROR_INVALIDDATA; + } else if (avio_tell(pb) <= next) /* only seek forward, else this can loop for a long time */ + avio_seek(pb, next, SEEK_SET); } if (ctx_size) ctx->type = type; return ctx_size ? mxf_add_metadata_set(mxf, ctx) : 0; @@ -1448,33 +1917,33 @@ static int mxf_parse_handle_essence(MXFContext *mxf) AVIOContext *pb = mxf->fc->pb; int64_t ret; - if (!mxf->current_partition) { - av_log(mxf->fc, AV_LOG_ERROR, "found essence prior to PartitionPack\n"); - return AVERROR_INVALIDDATA; - } - if (mxf->parsing_backward) { return mxf_seek_to_previous_partition(mxf); } else { - if (!mxf->footer_partition) { - av_dlog(mxf->fc, "no footer\n"); + uint64_t offset = mxf->footer_partition ? mxf->footer_partition + : mxf->last_partition; + + if (!offset) { + av_dlog(mxf->fc, "no last partition\n"); return 0; } - av_dlog(mxf->fc, "seeking to footer\n"); + av_dlog(mxf->fc, "seeking to last partition\n"); /* remember where we were so we don't end up seeking further back than this */ mxf->last_forward_tell = avio_tell(pb); if (!pb->seekable) { - av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing footer\n"); + av_log(mxf->fc, AV_LOG_INFO, "file is not seekable - not parsing last partition\n"); return -1; } - /* seek to footer partition and parse backward */ - if ((ret = avio_seek(pb, mxf->run_in + mxf->footer_partition, SEEK_SET)) < 0) { - av_log(mxf->fc, AV_LOG_ERROR, "failed to seek to footer @ 0x%"PRIx64" (%"PRId64") - partial file?\n", - mxf->run_in + mxf->footer_partition, ret); + /* seek to last partition and parse backward */ + if ((ret = avio_seek(pb, mxf->run_in + offset, SEEK_SET)) < 0) { + av_log(mxf->fc, AV_LOG_ERROR, + "failed to seek to last partition @ 0x%" PRIx64 + " (%"PRId64") - partial file?\n", + mxf->run_in + offset, ret); return ret; } @@ -1521,7 +1990,8 @@ static void mxf_compute_essence_containers(MXFContext *mxf) if (p->essence_length < 0) { /* next ThisPartition < essence_offset */ p->essence_length = 0; - av_log(mxf->fc, AV_LOG_ERROR, "partition %i: bad ThisPartition = %lx\n", + av_log(mxf->fc, AV_LOG_ERROR, + "partition %i: bad ThisPartition = %"PRIX64"\n", x+1, mxf->partitions[x+1].this_partition); } } @@ -1567,13 +2037,79 @@ static inline void compute_partition_essence_offset(AVFormatContext *s, } } -static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) +static int is_pcm(enum AVCodecID codec_id) +{ + /* we only care about "normal" PCM codecs until we get samples */ + return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD; +} + +/** + * Deal with the case where for some audio atoms EditUnitByteCount is + * very small (2, 4..). In those cases we should read more than one + * sample per call to mxf_read_packet(). + */ +static void mxf_handle_small_eubc(AVFormatContext *s) +{ + MXFContext *mxf = s->priv_data; + + /* assuming non-OPAtom == frame wrapped + * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */ + if (mxf->op != OPAtom) + return; + + /* expect PCM with exactly one index table segment and a small (< 32) EUBC */ + if (s->nb_streams != 1 || + s->streams[0]->codec->codec_type != AVMEDIA_TYPE_AUDIO || + !is_pcm(s->streams[0]->codec->codec_id) || + mxf->nb_index_tables != 1 || + mxf->index_tables[0].nb_segments != 1 || + mxf->index_tables[0].segments[0]->edit_unit_byte_count >= 32) + return; + + /* arbitrarily default to 48 kHz PAL audio frame size */ + /* TODO: We could compute this from the ratio between the audio + * and video edit rates for 48 kHz NTSC we could use the + * 1802-1802-1802-1802-1801 pattern. */ + mxf->edit_units_per_packet = 1920; +} + +static void mxf_read_random_index_pack(AVFormatContext *s) +{ + MXFContext *mxf = s->priv_data; + uint32_t length; + int64_t file_size; + KLVPacket klv; + + if (!s->pb->seekable) + return; + + file_size = avio_size(s->pb); + avio_seek(s->pb, file_size - 4, SEEK_SET); + length = avio_rb32(s->pb); + if (length <= 32 || length >= FFMIN(file_size, INT_MAX)) + goto end; + avio_seek(s->pb, file_size - length, SEEK_SET); + if (klv_read_packet(&klv, s->pb) < 0 || + !IS_KLV_KEY(klv.key, mxf_random_index_pack_key) || + klv.length != length - 20) + goto end; + + avio_skip(s->pb, klv.length - 12); + mxf->last_partition = avio_rb64(s->pb); + +end: + avio_seek(s->pb, mxf->run_in, SEEK_SET); +} + +static int mxf_read_header(AVFormatContext *s) { MXFContext *mxf = s->priv_data; KLVPacket klv; int64_t essence_offset = 0; + int ret; mxf->last_forward_tell = INT64_MAX; + mxf->edit_units_per_packet = 1; if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) { av_log(s, AV_LOG_ERROR, "could not find header partition pack key\n"); @@ -1583,7 +2119,10 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) mxf->fc = s; mxf->run_in = avio_tell(s->pb); + mxf_read_random_index_pack(s); + while (!s->pb->eof_reached) { + const MXFMetadataReadTableEntry *metadata; if (klv_read_packet(&klv, s->pb) < 0) { @@ -1598,7 +2137,15 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key) || IS_KLV_KEY(klv.key, mxf_essence_element_key) || + IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) || IS_KLV_KEY(klv.key, mxf_system_item_key)) { + + if (!mxf->current_partition) { + av_log(mxf->fc, AV_LOG_ERROR, + "found essence prior to first PartitionPack\n"); + return AVERROR_INVALIDDATA; + } + if (!mxf->current_partition->essence_offset) { compute_partition_essence_offset(s, mxf, &klv); } @@ -1615,6 +2162,9 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) /* next partition pack - keep going, seek to previous partition or stop */ if(mxf_parse_handle_partition_or_eof(mxf) <= 0) break; + else if (mxf->parsing_backward) + continue; + /* we're still parsing forward. proceed to parsing this partition pack */ } for (metadata = mxf_metadata_read_table; metadata->read; metadata++) { @@ -1625,6 +2175,14 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) } else { uint64_t next = avio_tell(s->pb) + klv.length; res = metadata->read(mxf, s->pb, 0, klv.length, klv.key, klv.offset); + + /* only seek forward, else this can loop for a long time */ + if (avio_tell(s->pb) > next) { + av_log(s, AV_LOG_ERROR, "read past end of KLV @ %#"PRIx64"\n", + klv.offset); + return AVERROR_INVALIDDATA; + } + avio_seek(s->pb, next, SEEK_SET); } if (res < 0) { @@ -1632,6 +2190,9 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) return res; } break; + } else { + av_log(s, AV_LOG_VERBOSE, "Dark key " PRIxUID "\n", + UID_ARG(klv.key)); } } if (!metadata->read) @@ -1646,14 +2207,304 @@ static int mxf_read_header(AVFormatContext *s, AVFormatParameters *ap) mxf_compute_essence_containers(mxf); - return mxf_parse_structural_metadata(mxf); + /* we need to do this before computing the index tables + * to be able to fill in zero IndexDurations with st->duration */ + if ((ret = mxf_parse_structural_metadata(mxf)) < 0) + return ret; + + if ((ret = mxf_compute_index_tables(mxf)) < 0) + return ret; + + if (mxf->nb_index_tables > 1) { + /* TODO: look up which IndexSID to use via EssenceContainerData */ + av_log(mxf->fc, AV_LOG_INFO, "got %i index tables - only the first one (IndexSID %i) will be used\n", + mxf->nb_index_tables, mxf->index_tables[0].index_sid); + } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom) { + av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n"); + return AVERROR_INVALIDDATA; + } + + mxf_handle_small_eubc(s); + + return 0; +} + +/** + * Sets mxf->current_edit_unit based on what offset we're currently at. + * @return next_ofs if OK, <0 on error + */ +static int64_t mxf_set_current_edit_unit(MXFContext *mxf, int64_t current_offset) +{ + int64_t last_ofs = -1, next_ofs = -1; + MXFIndexTable *t = &mxf->index_tables[0]; + + /* this is called from the OP1a demuxing logic, which means there + * may be no index tables */ + if (mxf->nb_index_tables <= 0) + return -1; + + /* find mxf->current_edit_unit so that the next edit unit starts ahead + * of current_offset */ + while (mxf->current_edit_unit >= 0) { + if (mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + 1, + NULL, &next_ofs, 0) < 0) + return -1; + + if (next_ofs <= last_ofs) { + /* large next_ofs didn't change or current_edit_unit wrapped + * around this fixes the infinite loop on zzuf3.mxf */ + av_log(mxf->fc, AV_LOG_ERROR, + "next_ofs didn't change. not deriving packet timestamps\n"); + return -1; + } + + if (next_ofs > current_offset) + break; + + last_ofs = next_ofs; + mxf->current_edit_unit++; + } + + /* not checking mxf->current_edit_unit >= t->nb_ptses here since CBR files + * may lack IndexEntryArrays */ + if (mxf->current_edit_unit < 0) + return -1; + + return next_ofs; +} + +static int mxf_compute_sample_count(MXFContext *mxf, int stream_index, + uint64_t *sample_count) +{ + int i, total = 0, size = 0; + AVStream *st = mxf->fc->streams[stream_index]; + MXFTrack *track = st->priv_data; + AVRational time_base = av_inv_q(track->edit_rate); + AVRational sample_rate = av_inv_q(st->time_base); + const MXFSamplesPerFrame *spf = NULL; + + if ((sample_rate.num / sample_rate.den) == 48000) + spf = ff_mxf_get_samples_per_frame(mxf->fc, time_base); + if (!spf) { + int remainder = (sample_rate.num * time_base.num) % + (time_base.den * sample_rate.den); + *sample_count = av_q2d(av_mul_q((AVRational){mxf->current_edit_unit, 1}, + av_mul_q(sample_rate, time_base))); + if (remainder) + av_log(mxf->fc, AV_LOG_WARNING, + "seeking detected on stream #%d with time base (%d/%d) and " + "sample rate (%d/%d), audio pts won't be accurate.\n", + stream_index, time_base.num, time_base.den, + sample_rate.num, sample_rate.den); + return 0; + } + + while (spf->samples_per_frame[size]) { + total += spf->samples_per_frame[size]; + size++; + } + + if (!size) + return 0; + + *sample_count = (mxf->current_edit_unit / size) * (uint64_t)total; + for (i = 0; i < mxf->current_edit_unit % size; i++) { + *sample_count += spf->samples_per_frame[i]; + } + + return 0; } +static int mxf_set_audio_pts(MXFContext *mxf, AVCodecContext *codec, + AVPacket *pkt) +{ + MXFTrack *track = mxf->fc->streams[pkt->stream_index]->priv_data; + int64_t bits_per_sample = codec->bits_per_coded_sample; + + if (!bits_per_sample) + bits_per_sample = av_get_bits_per_sample(codec->codec_id); + + pkt->pts = track->sample_count; + + if (codec->channels <= 0 || codec->channels * bits_per_sample < 8) + return AVERROR_INVALIDDATA; + + track->sample_count += pkt->size / (codec->channels * bits_per_sample / 8); + return 0; +} + +static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt) +{ + KLVPacket klv; + MXFContext *mxf = s->priv_data; + int ret; + + while (!s->pb->eof_reached) { + if ((ret = klv_read_packet(&klv, s->pb)) < 0) + return ret; + PRINT_KEY(s, "read packet", klv.key); + av_dlog(s, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); + if (IS_KLV_KEY(klv.key, mxf_encrypted_triplet_key)) { + ret = mxf_decrypt_triplet(s, pkt, &klv); + if (ret < 0) { + av_log(s, AV_LOG_ERROR, "invalid encoded triplet\n"); + return ret; + } + return 0; + } + if (IS_KLV_KEY(klv.key, mxf_essence_element_key) || + IS_KLV_KEY(klv.key, mxf_avid_essence_element_key)) { + int index = mxf_get_stream_index(s, &klv); + int64_t next_ofs, next_klv; + AVStream *st; + MXFTrack *track; + AVCodecContext *codec; + + if (index < 0) { + av_log(s, AV_LOG_ERROR, + "error getting stream index %"PRIu32"\n", + AV_RB32(klv.key + 12)); + goto skip; + } + + st = s->streams[index]; + track = st->priv_data; + + if (s->streams[index]->discard == AVDISCARD_ALL) + goto skip; + + next_klv = avio_tell(s->pb) + klv.length; + next_ofs = mxf_set_current_edit_unit(mxf, klv.offset); + + if (next_ofs >= 0 && next_klv > next_ofs) { + /* if this check is hit then it's possible OPAtom was treated + * as OP1a truncate the packet since it's probably very large + * (>2 GiB is common) */ + avpriv_request_sample(s, + "OPAtom misinterpreted as OP1a?" + "KLV for edit unit %i extending into " + "next edit unit", + mxf->current_edit_unit); + klv.length = next_ofs - avio_tell(s->pb); + } + + /* check for 8 channels AES3 element */ + if (klv.key[12] == 0x06 && klv.key[13] == 0x01 && klv.key[14] == 0x10) { + ret = mxf_get_d10_aes3_packet(s->pb, s->streams[index], + pkt, klv.length); + if (ret < 0) { + av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n"); + return ret; + } + } else { + ret = av_get_packet(s->pb, pkt, klv.length); + if (ret < 0) + return ret; + } + pkt->stream_index = index; + pkt->pos = klv.offset; + + codec = s->streams[index]->codec; + + if (codec->codec_type == AVMEDIA_TYPE_VIDEO && next_ofs >= 0) { + /* mxf->current_edit_unit good - see if we have an + * index table to derive timestamps from */ + MXFIndexTable *t = &mxf->index_tables[0]; + + if (mxf->nb_index_tables >= 1 && + mxf->current_edit_unit < t->nb_ptses) { + pkt->dts = mxf->current_edit_unit + t->first_dts; + pkt->pts = t->ptses[mxf->current_edit_unit]; + } else if (track->intra_only) { + /* intra-only -> PTS = EditUnit. + * let utils.c figure out DTS since it can be + * < PTS if low_delay = 0 (Sony IMX30) */ + pkt->pts = mxf->current_edit_unit; + } + } else if (codec->codec_type == AVMEDIA_TYPE_AUDIO) { + ret = mxf_set_audio_pts(mxf, codec, pkt); + if (ret < 0) + return ret; + } + + /* seek for truncated packets */ + avio_seek(s->pb, next_klv, SEEK_SET); + + return 0; + } else + skip: + avio_skip(s->pb, klv.length); + } + return AVERROR_EOF; +} + +static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt) +{ + MXFContext *mxf = s->priv_data; + int ret, size; + int64_t ret64, pos, next_pos; + AVStream *st; + MXFIndexTable *t; + int edit_units; + + if (mxf->op != OPAtom) + return mxf_read_packet_old(s, pkt); + + /* OPAtom - clip wrapped demuxing */ + /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */ + st = s->streams[0]; + t = &mxf->index_tables[0]; + + if (mxf->current_edit_unit >= st->duration) + return AVERROR_EOF; + + edit_units = FFMIN(mxf->edit_units_per_packet, st->duration - mxf->current_edit_unit); + + if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit, NULL, &pos, 1)) < 0) + return ret; + + /* compute size by finding the next edit unit or the end of the essence container + * not pretty, but it works */ + if ((ret = mxf_edit_unit_absolute_offset(mxf, t, mxf->current_edit_unit + edit_units, NULL, &next_pos, 0)) < 0 && + (next_pos = mxf_essence_container_end(mxf, t->body_sid)) <= 0) { + av_log(s, AV_LOG_ERROR, "unable to compute the size of the last packet\n"); + return AVERROR_INVALIDDATA; + } + + if ((size = next_pos - pos) <= 0) { + av_log(s, AV_LOG_ERROR, "bad size: %i\n", size); + return AVERROR_INVALIDDATA; + } + + if ((ret64 = avio_seek(s->pb, pos, SEEK_SET)) < 0) + return ret64; + + if ((ret = av_get_packet(s->pb, pkt, size)) != size) + return ret < 0 ? ret : AVERROR_EOF; + + pkt->stream_index = 0; + + if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && t->ptses && + mxf->current_edit_unit >= 0 && mxf->current_edit_unit < t->nb_ptses) { + pkt->dts = mxf->current_edit_unit + t->first_dts; + pkt->pts = t->ptses[mxf->current_edit_unit]; + } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { + int ret = mxf_set_audio_pts(mxf, st->codec, pkt); + if (ret < 0) + return ret; + } + + mxf->current_edit_unit += edit_units; + + return 0; +} + + static int mxf_read_close(AVFormatContext *s) { MXFContext *mxf = s->priv_data; MXFIndexTableSegment *seg; - int i, j; + int i; av_freep(&mxf->packages_refs); @@ -1662,6 +2513,9 @@ static int mxf_read_close(AVFormatContext *s) for (i = 0; i < mxf->metadata_sets_count; i++) { switch (mxf->metadata_sets[i]->type) { + case Descriptor: + av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->extradata); + break; case MultipleDescriptor: av_freep(&((MXFDescriptor *)mxf->metadata_sets[i])->sub_descriptors_refs); break; @@ -1674,15 +2528,9 @@ static int mxf_read_close(AVFormatContext *s) break; case IndexTableSegment: seg = (MXFIndexTableSegment *)mxf->metadata_sets[i]; - if (seg->slice_count) - for (j = 0; j < seg->nb_index_entries; j++) - av_freep(&seg->slice_offset_entries[j]); - av_freep(&seg->slice); - av_freep(&seg->element_delta); av_freep(&seg->temporal_offset_entries); av_freep(&seg->flag_entries); av_freep(&seg->stream_offset_entries); - av_freep(&seg->slice_offset_entries); break; default: break; @@ -1693,6 +2541,14 @@ static int mxf_read_close(AVFormatContext *s) av_freep(&mxf->metadata_sets); av_freep(&mxf->aesc); av_freep(&mxf->local_tags); + + for (i = 0; i < mxf->nb_index_tables; i++) { + av_freep(&mxf->index_tables[i].segments); + av_freep(&mxf->index_tables[i].ptses); + av_freep(&mxf->index_tables[i].fake_index); + } + av_freep(&mxf->index_tables); + return 0; } @@ -1718,23 +2574,74 @@ static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti { AVStream *st = s->streams[stream_index]; int64_t seconds; - int ret; - + MXFContext* mxf = s->priv_data; + int64_t seekpos; + int i, ret; + MXFIndexTable *t; + MXFTrack *source_track = st->priv_data; + + /* if audio then truncate sample_time to EditRate */ + if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) + sample_time = av_rescale_q(sample_time, st->time_base, + av_inv_q(source_track->edit_rate)); + + if (mxf->nb_index_tables <= 0) { if (!s->bit_rate) return AVERROR_INVALIDDATA; if (sample_time < 0) sample_time = 0; seconds = av_rescale(sample_time, st->time_base.num, st->time_base.den); - if ((ret = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET)) < 0) - return ret; + seekpos = avio_seek(s->pb, (s->bit_rate * seconds) >> 3, SEEK_SET); + if (seekpos < 0) + return seekpos; + ff_update_cur_dts(s, st, sample_time); + mxf->current_edit_unit = sample_time; + } else { + t = &mxf->index_tables[0]; + + /* clamp above zero, else ff_index_search_timestamp() returns negative + * this also means we allow seeking before the start */ + sample_time = FFMAX(sample_time, 0); + + if (t->fake_index) { + /* behave as if we have a proper index */ + if ((sample_time = ff_index_search_timestamp(t->fake_index, t->nb_ptses, sample_time, flags)) < 0) + return sample_time; + } else { + /* no IndexEntryArray (one or more CBR segments) + * make sure we don't seek past the end */ + sample_time = FFMIN(sample_time, source_track->original_duration - 1); + } + + if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, &sample_time, &seekpos, 1)) << 0) + return ret; + + ff_update_cur_dts(s, st, sample_time); + mxf->current_edit_unit = sample_time; + avio_seek(s->pb, seekpos, SEEK_SET); + } + + // Update all tracks sample count + for (i = 0; i < s->nb_streams; i++) { + AVStream *cur_st = s->streams[i]; + MXFTrack *cur_track = cur_st->priv_data; + uint64_t current_sample_count = 0; + if (cur_st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { + ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count); + if (ret < 0) + return ret; + + cur_track->sample_count = current_sample_count; + } + } return 0; } AVInputFormat ff_mxf_demuxer = { .name = "mxf", - .long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format"), + .long_name = NULL_IF_CONFIG_SMALL("MXF (Material eXchange Format)"), .priv_data_size = sizeof(MXFContext), .read_probe = mxf_probe, .read_header = mxf_read_header,