#include "internal.h"
#include "mxf.h"
+#define MXF_MAX_CHUNK_SIZE (32 << 20)
+
typedef enum {
Header,
BodyPartition,
int index_sid;
int body_sid;
MXFWrappingScheme wrapping;
+ int edit_units_per_packet; /* how many edit units to read at a time (PCM, ClipWrapped) */
} MXFTrack;
typedef struct MXFDescriptor {
int local_tags_count;
uint64_t footer_partition;
KLVPacket current_klv_data;
- int current_klv_index;
int run_in;
MXFPartition *current_partition;
int parsing_backward;
int64_t last_forward_tell;
int last_forward_partition;
- int64_t 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;
/* NOTE: klv_offset is not set (-1) for local keys */
return i;
}
/* return 0 if only one stream, for OP Atom files with 0 as track number */
- return s->nb_streams == 1 ? 0 : -1;
+ return s->nb_streams == 1 && s->streams[0]->priv_data ? 0 : -1;
}
static int find_body_sid_by_offset(MXFContext *mxf, int64_t offset)
return AVERROR(ENOMEM);
}
- for (i = j = 0; i < mxf->metadata_sets_count; i++)
- if (mxf->metadata_sets[i]->type == IndexTableSegment)
- unsorted_segments[j++] = (MXFIndexTableSegment*)mxf->metadata_sets[i];
+ for (i = nb_segments = 0; i < mxf->metadata_sets_count; i++) {
+ if (mxf->metadata_sets[i]->type == IndexTableSegment) {
+ MXFIndexTableSegment *s = (MXFIndexTableSegment*)mxf->metadata_sets[i];
+ if (s->edit_unit_byte_count || s->nb_index_entries)
+ unsorted_segments[nb_segments++] = s;
+ else
+ av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment at %"PRId64" missing EditUnitByteCount and IndexEntryArray\n",
+ s->index_sid, s->index_start_position);
+ }
+ }
+
+ if (!nb_segments) {
+ av_freep(sorted_segments);
+ av_free(unsorted_segments);
+ return AVERROR_INVALIDDATA;
+ }
*nb_sorted_segments = 0;
/**
* Computes the absolute file offset of the given essence container offset
*/
-static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out)
+static int mxf_absolute_bodysid_offset(MXFContext *mxf, int body_sid, int64_t offset, int64_t *offset_out, MXFPartition **partition_out)
{
MXFPartition *last_p = NULL;
int a, b, m, m0;
if (last_p && (!last_p->essence_length || last_p->essence_length > (offset - last_p->body_offset))) {
*offset_out = last_p->essence_offset + (offset - last_p->body_offset);
+ if (partition_out)
+ *partition_out = last_p;
return 0;
}
}
/* 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)
+static int mxf_edit_unit_absolute_offset(MXFContext *mxf, MXFIndexTable *index_table, int64_t edit_unit, AVRational edit_rate, int64_t *edit_unit_out, int64_t *offset_out, MXFPartition **partition_out, int nag)
{
int i;
int64_t offset_temp = 0;
+ edit_unit = av_rescale_q(edit_unit, index_table->segments[0]->index_edit_rate, edit_rate);
+
for (i = 0; i < index_table->nb_segments; i++) {
MXFIndexTableSegment *s = index_table->segments[i];
if (s->edit_unit_byte_count)
offset_temp += s->edit_unit_byte_count * index;
- else if (s->nb_index_entries) {
+ else {
if (s->nb_index_entries == 2 * s->index_duration + 1)
index *= 2; /* Avid index */
}
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 (edit_unit_out)
- *edit_unit_out = edit_unit;
+ *edit_unit_out = av_rescale_q(edit_unit, edit_rate, s->index_edit_rate);
- return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out);
+ return mxf_absolute_bodysid_offset(mxf, index_table->body_sid, offset_temp, offset_out, partition_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;
return 0; /* no TemporalOffsets */
}
+ if (s->index_duration > INT_MAX - index_table->nb_ptses) {
+ index_table->nb_ptses = 0;
+ av_log(mxf->fc, AV_LOG_ERROR, "ignoring IndexSID %d, duration is too large\n", s->index_sid);
+ return 0;
+ }
+
index_table->nb_ptses += s->index_duration;
}
/* fix zero IndexDurations */
for (k = 0; k < t->nb_segments; k++) {
+ if (!t->segments[k]->index_edit_rate.num || !t->segments[k]->index_edit_rate.den) {
+ av_log(mxf->fc, AV_LOG_WARNING, "IndexSID %i segment %i has invalid IndexEditRate\n",
+ t->index_sid, k);
+ if (mxf_track)
+ t->segments[k]->index_edit_rate = mxf_track->edit_rate;
+ }
+
if (t->segments[k]->index_duration)
continue;
MXFEssenceContainerData *essence_data;
if (!(essence_data = mxf_resolve_strong_ref(mxf, &mxf->essence_container_data_refs[k], EssenceContainerData))) {
- av_log(mxf, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
+ av_log(mxf->fc, AV_LOG_TRACE, "could not resolve essence container data strong ref\n");
continue;
}
if (!memcmp(component->source_package_ul, essence_data->package_ul, sizeof(UID)) && !memcmp(component->source_package_uid, essence_data->package_uid, sizeof(UID))) {
if (ret < 0)
return ret;
}
- if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && (*essence_container_ul)[15] > 0x01) {
+ if (st->codecpar->codec_type != AVMEDIA_TYPE_DATA && source_track->wrapping != FrameWrapped) {
/* TODO: decode timestamps */
st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
}
if (ctx_size && tag == 0x3C0A) {
avio_read(pb, ctx->uid, 16);
} else if ((ret = read_child(ctx, pb, tag, size, uid, -1)) < 0) {
- mxf_free_metadataset(&ctx, !!ctx_size);
+ if (ctx_size)
+ mxf_free_metadataset(&ctx, 1);
return ret;
}
if (avio_tell(pb) > klv_end) {
if (ctx_size) {
ctx->type = type;
- mxf_free_metadataset(&ctx, !!ctx_size);
+ mxf_free_metadataset(&ctx, 1);
}
av_log(mxf->fc, AV_LOG_ERROR,
return mxf->parsing_backward ? mxf_seek_to_previous_partition(mxf) : 1;
}
-static int64_t round_to_kag(int64_t position, int kag_size)
-{
- /* TODO: account for run-in? the spec isn't clear whether KAG should account for it */
- /* NOTE: kag_size may be any integer between 1 - 2^10 */
- int64_t ret = (position / kag_size) * kag_size;
- return ret == position ? ret : ret + kag_size;
-}
-
static MXFWrappingScheme mxf_get_wrapping_by_body_sid(AVFormatContext *s, int body_sid)
{
for (int i = 0; i < s->nb_streams; i++) {
if (!p->body_sid)
continue; /* BodySID == 0 -> no essence */
- /* for non clip-wrapped essences we compute essence_offset
- * for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
+ /* for clip wrapped essences we point essence_offset after the KL (usually klv.offset + 20 or 25)
+ * otherwise we point essence_offset at the key of the first essence KLV.
*/
wrapping = (mxf->op == OPAtom) ? ClipWrapped : mxf_get_wrapping_by_body_sid(s, p->body_sid);
p->essence_offset = p->first_essence_klv.next_klv - p->first_essence_klv.length;
p->essence_length = p->first_essence_klv.length;
} else {
- int64_t op1a_essence_offset =
- p->this_partition +
- round_to_kag(p->pack_length, p->kag_size) +
- round_to_kag(p->header_byte_count, p->kag_size) +
- round_to_kag(p->index_byte_count, p->kag_size);
-
- /* NOTE: op1a_essence_offset may be less than to klv.offset (C0023S01.mxf) */
- if (IS_KLV_KEY(p->first_essence_klv.key, mxf_system_item_key_cp) || IS_KLV_KEY(p->first_essence_klv.key, mxf_system_item_key_gc))
- p->essence_offset = p->first_essence_klv.offset;
- else
- p->essence_offset = op1a_essence_offset;
+ p->essence_offset = p->first_essence_klv.offset;
/* essence container spans to the next partition */
if (x < mxf->partitions_count - 1)
return codec_id >= AV_CODEC_ID_PCM_S16LE && codec_id < AV_CODEC_ID_PCM_S24DAUD;
}
-static AVStream* mxf_get_opatom_stream(MXFContext *mxf)
+static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
{
int i;
-
- if (mxf->op != OPAtom)
- return NULL;
-
- for (i = 0; i < mxf->fc->nb_streams; i++) {
- if (mxf->fc->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_DATA)
- continue;
- return mxf->fc->streams[i];
- }
+ for (i = 0; i < mxf->nb_index_tables; i++)
+ if (mxf->index_tables[i].index_sid == index_sid)
+ return &mxf->index_tables[i];
return NULL;
}
* 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)
+static void mxf_compute_edit_units_per_packet(MXFContext *mxf, AVStream *st)
{
- MXFContext *mxf = s->priv_data;
- MXFTrack *track;
+ MXFTrack *track = st->priv_data;
+ MXFIndexTable *t;
- /* assuming non-OPAtom == frame wrapped
- * no sane writer would wrap 2 byte PCM packets with 20 byte headers.. */
- AVStream *st = mxf_get_opatom_stream(mxf);
- if (!st)
+ if (!track)
return;
+ track->edit_units_per_packet = 1;
+ if (track->wrapping != ClipWrapped)
+ return;
+
+ t = mxf_find_index_table(mxf, track->index_sid);
/* expect PCM with exactly one index table segment and a small (< 32) EUBC */
if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO ||
!is_pcm(st->codecpar->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)
+ !t ||
+ t->nb_segments != 1 ||
+ t->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. */
- track = st->priv_data;
- mxf->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
+ track->edit_units_per_packet = FFMAX(1, track->edit_rate.num / track->edit_rate.den / 25);
}
/**
MXFIndexTableSegment *segment = NULL;
MXFPartition *p = NULL;
int essence_partition_count = 0;
+ int edit_unit_byte_count = 0;
int i, ret;
- /* TODO: support raw video without an index if they exist */
- if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO || !is_pcm(st->codecpar->codec_id) || track->wrapping != ClipWrapped)
+ if (!track || track->wrapping != ClipWrapped)
return 0;
/* check if track already has an IndexTableSegment */
if (essence_partition_count != 1)
return 0;
+ if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && is_pcm(st->codecpar->codec_id)) {
+ edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
+ } else if (st->duration > 0 && p->first_essence_klv.length > 0 && p->first_essence_klv.length % st->duration == 0) {
+ edit_unit_byte_count = p->first_essence_klv.length / st->duration;
+ }
+
+ if (edit_unit_byte_count <= 0)
+ return 0;
+
+ av_log(mxf->fc, AV_LOG_WARNING, "guessing index for stream %d using edit unit byte count %d\n", st->index, edit_unit_byte_count);
+
if (!(segment = av_mallocz(sizeof(*segment))))
return AVERROR(ENOMEM);
* using the same SID for index is forbidden in MXF. */
if (!track->index_sid)
track->index_sid = track->body_sid;
- track->edit_rate = av_inv_q(st->time_base);
segment->type = IndexTableSegment;
/* stream will be treated as small EditUnitByteCount */
- segment->edit_unit_byte_count = (av_get_bits_per_sample(st->codecpar->codec_id) * st->codecpar->channels) >> 3;
+ segment->edit_unit_byte_count = edit_unit_byte_count;
segment->index_start_position = 0;
segment->index_duration = st->duration;
- segment->index_edit_rate = track->edit_rate;
+ segment->index_edit_rate = av_inv_q(st->time_base);
segment->index_sid = track->index_sid;
segment->body_sid = p->body_sid;
return 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");
av_log(s, AV_LOG_TRACE, "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_canopus_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_avid_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_system_item_key_cp) ||
IS_KLV_KEY(klv.key, mxf_system_item_key_gc)) {
/* 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) {
+ } else if (mxf->nb_index_tables == 0 && mxf->op == OPAtom && (s->error_recognition & AV_EF_EXPLODE)) {
av_log(mxf->fc, AV_LOG_ERROR, "cannot demux OPAtom without an index\n");
ret = AVERROR_INVALIDDATA;
goto fail;
mxf_compute_essence_containers(s);
- mxf_handle_small_eubc(s);
+ for (int i = 0; i < s->nb_streams; i++)
+ mxf_compute_edit_units_per_packet(mxf, s->streams[i]);
return 0;
fail:
return ret;
}
-static MXFIndexTable *mxf_find_index_table(MXFContext *mxf, int index_sid)
-{
- int i;
- for (i = 0; i < mxf->nb_index_tables; i++)
- if (mxf->index_tables[i].index_sid == index_sid)
- return &mxf->index_tables[i];
- return NULL;
-}
-
/* Get the edit unit of the next packet from current_offset in a track. The returned edit unit can be original_duration as well! */
static int mxf_get_next_track_edit_unit(MXFContext *mxf, MXFTrack *track, int64_t current_offset, int64_t *edit_unit_out)
{
while (b - a > 1) {
m = (a + b) >> 1;
- if (mxf_edit_unit_absolute_offset(mxf, t, m, NULL, &offset, 0) < 0)
+ if (mxf_edit_unit_absolute_offset(mxf, t, m, track->edit_rate, NULL, &offset, NULL, 0) < 0)
return -1;
if (offset < current_offset)
a = m;
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 -2;
-
- 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)
+static int64_t mxf_compute_sample_count(MXFContext *mxf, AVStream *st,
+ int64_t edit_unit)
{
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;
+ int64_t sample_count;
+
+ // For non-audio sample_count equals current edit unit
+ if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO)
+ return edit_unit;
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_rescale_q(mxf->current_edit_unit, sample_rate, track->edit_rate);
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,
+ st->index, time_base.num, time_base.den,
sample_rate.num, sample_rate.den);
- return 0;
+ return av_rescale_q(edit_unit, sample_rate, track->edit_rate);
}
while (spf->samples_per_frame[size]) {
av_assert2(size);
- *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];
+ sample_count = (edit_unit / size) * (uint64_t)total;
+ for (i = 0; i < edit_unit % size; i++) {
+ sample_count += spf->samples_per_frame[i];
}
- return 0;
+ return sample_count;
+}
+
+/**
+ * Make sure track->sample_count is correct based on what offset we're currently at.
+ * Also determine the next edit unit (or packet) offset.
+ * @return next_ofs if OK, <0 on error
+ */
+static int64_t mxf_set_current_edit_unit(MXFContext *mxf, AVStream *st, int64_t current_offset, int resync)
+{
+ int64_t next_ofs = -1;
+ MXFTrack *track = st->priv_data;
+ int64_t edit_unit = av_rescale_q(track->sample_count, st->time_base, av_inv_q(track->edit_rate));
+ int64_t new_edit_unit;
+ MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
+
+ if (!t || track->wrapping == UnknownWrapped)
+ return -1;
+
+ if (mxf_edit_unit_absolute_offset(mxf, t, edit_unit + track->edit_units_per_packet, track->edit_rate, NULL, &next_ofs, NULL, 0) < 0 &&
+ (next_ofs = mxf_essence_container_end(mxf, t->body_sid)) <= 0) {
+ av_log(mxf->fc, AV_LOG_ERROR, "unable to compute the size of the last packet\n");
+ return -1;
+ }
+
+ /* check if the next edit unit offset (next_ofs) starts ahead of current_offset */
+ if (next_ofs > current_offset)
+ return next_ofs;
+
+ if (!resync) {
+ av_log(mxf->fc, AV_LOG_ERROR, "cannot find current edit unit for stream %d, invalid index?\n", st->index);
+ return -1;
+ }
+
+ if (mxf_get_next_track_edit_unit(mxf, track, current_offset + 1, &new_edit_unit) < 0 || new_edit_unit <= 0) {
+ av_log(mxf->fc, AV_LOG_ERROR, "failed to find next track edit unit in stream %d\n", st->index);
+ return -1;
+ }
+
+ new_edit_unit--;
+ track->sample_count = mxf_compute_sample_count(mxf, st, new_edit_unit);
+ av_log(mxf->fc, AV_LOG_WARNING, "edit unit sync lost on stream %d, jumping from %"PRId64" to %"PRId64"\n", st->index, edit_unit, new_edit_unit);
+
+ return mxf_set_current_edit_unit(mxf, st, current_offset, 0);
}
static int mxf_set_audio_pts(MXFContext *mxf, AVCodecParameters *par,
return 0;
}
-static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt, int64_t next_ofs)
+static int mxf_set_pts(MXFContext *mxf, AVStream *st, AVPacket *pkt)
{
AVCodecParameters *par = st->codecpar;
MXFTrack *track = st->priv_data;
- if (par->codec_type == AVMEDIA_TYPE_VIDEO && (next_ofs >= 0 || next_ofs == -2 && st->duration == mxf->current_edit_unit + 1)) {
- /* mxf->current_edit_unit good - see if we have an
- * index table to derive timestamps from */
- MXFIndexTable *t = &mxf->index_tables[0];
+ if (par->codec_type == AVMEDIA_TYPE_VIDEO) {
+ /* see if we have an index table to derive timestamps from */
+ MXFIndexTable *t = mxf_find_index_table(mxf, track->index_sid);
- 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];
+ if (t && track->sample_count < t->nb_ptses) {
+ pkt->dts = track->sample_count + t->first_dts;
+ pkt->pts = t->ptses[track->sample_count];
} 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;
+ pkt->pts = track->sample_count;
}
+ track->sample_count++;
} else if (par->codec_type == AVMEDIA_TYPE_AUDIO) {
int ret = mxf_set_audio_pts(mxf, par, pkt);
if (ret < 0)
return ret;
+ } else if (track) {
+ track->sample_count++;
}
return 0;
}
-static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt)
+static int mxf_read_packet(AVFormatContext *s, AVPacket *pkt)
{
KLVPacket klv;
MXFContext *mxf = s->priv_data;
int ret;
- while ((ret = klv_read_packet(&klv, s->pb)) == 0) {
- PRINT_KEY(s, "read packet", klv.key);
- av_log(s, AV_LOG_TRACE, "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;
+ while (1) {
+ int64_t max_data_size;
+ int64_t pos = avio_tell(s->pb);
+
+ if (pos < mxf->current_klv_data.next_klv - mxf->current_klv_data.length || pos >= mxf->current_klv_data.next_klv) {
+ mxf->current_klv_data = (KLVPacket){{0}};
+ ret = klv_read_packet(&klv, s->pb);
+ if (ret < 0)
+ break;
+ max_data_size = klv.length;
+ pos = klv.next_klv - klv.length;
+ PRINT_KEY(s, "read packet", klv.key);
+ av_log(s, AV_LOG_TRACE, "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;
}
- return 0;
+ } else {
+ klv = mxf->current_klv_data;
+ max_data_size = klv.next_klv - pos;
}
if (IS_KLV_KEY(klv.key, mxf_essence_element_key) ||
IS_KLV_KEY(klv.key, mxf_canopus_essence_element_key) ||
int index = mxf_get_stream_index(s, &klv, body_sid);
int64_t next_ofs;
AVStream *st;
+ MXFTrack *track;
if (index < 0) {
av_log(s, AV_LOG_ERROR,
}
st = s->streams[index];
+ track = st->priv_data;
if (s->streams[index]->discard == AVDISCARD_ALL)
goto skip;
- next_ofs = mxf_set_current_edit_unit(mxf, klv.offset);
-
- if (next_ofs >= 0 && klv.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 %"PRId64" extending into "
- "next edit unit",
- mxf->current_edit_unit);
- klv.length = next_ofs - avio_tell(s->pb);
+ next_ofs = mxf_set_current_edit_unit(mxf, st, pos, 1);
+
+ if (track->wrapping != FrameWrapped) {
+ int64_t size;
+
+ if (next_ofs <= 0) {
+ // If we have no way to packetize the data, then return it in chunks...
+ if (klv.next_klv - klv.length == pos && max_data_size > MXF_MAX_CHUNK_SIZE) {
+ st->need_parsing = AVSTREAM_PARSE_FULL;
+ avpriv_request_sample(s, "Huge KLV without proper index in non-frame wrapped essence");
+ }
+ size = FFMIN(max_data_size, MXF_MAX_CHUNK_SIZE);
+ } else {
+ if ((size = next_ofs - pos) <= 0) {
+ av_log(s, AV_LOG_ERROR, "bad size: %"PRId64"\n", size);
+ ret = AVERROR_INVALIDDATA;
+ goto skip;
+ }
+ // We must not overread, because the next edit unit might be in another KLV
+ if (size > max_data_size)
+ size = max_data_size;
+ }
+
+ mxf->current_klv_data = klv;
+ klv.offset = pos;
+ klv.length = size;
+ klv.next_klv = klv.offset + klv.length;
}
/* check for 8 channels AES3 element */
pkt, klv.length);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "error reading D-10 aes3 frame\n");
+ mxf->current_klv_data = (KLVPacket){{0}};
return ret;
}
} else {
ret = av_get_packet(s->pb, pkt, klv.length);
- if (ret < 0)
+ if (ret < 0) {
+ mxf->current_klv_data = (KLVPacket){{0}};
return ret;
+ }
}
pkt->stream_index = index;
pkt->pos = klv.offset;
- ret = mxf_set_pts(mxf, st, pkt, next_ofs);
- if (ret < 0)
+ ret = mxf_set_pts(mxf, st, pkt);
+ if (ret < 0) {
+ mxf->current_klv_data = (KLVPacket){{0}};
return ret;
+ }
/* seek for truncated packets */
avio_seek(s->pb, klv.next_klv, SEEK_SET);
return 0;
- } else
+ } else {
skip:
- avio_skip(s->pb, klv.length);
+ avio_skip(s->pb, max_data_size);
+ mxf->current_klv_data = (KLVPacket){{0}};
+ }
}
return avio_feof(s->pb) ? AVERROR_EOF : ret;
}
-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;
- MXFTrack *track;
- int edit_units;
-
- if (mxf->op != OPAtom)
- return mxf_read_packet_old(s, pkt);
-
- // If we have no streams then we basically are at EOF
- st = mxf_get_opatom_stream(mxf);
- if (!st)
- return AVERROR_EOF;
-
- track = st->priv_data;
-
- /* OPAtom - clip wrapped demuxing */
- /* NOTE: mxf_read_header() makes sure nb_index_tables > 0 for OPAtom */
- t = &mxf->index_tables[0];
-
- if (mxf->current_edit_unit >= track->original_duration)
- return AVERROR_EOF;
-
- edit_units = FFMIN(mxf->edit_units_per_packet, track->original_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 ((size = av_get_packet(s->pb, pkt, size)) < 0)
- return size;
-
- pkt->stream_index = st->index;
-
- ret = mxf_set_pts(mxf, st, pkt, next_pos);
- 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;
return seekpos;
ff_update_cur_dts(s, st, sample_time);
- mxf->current_edit_unit = sample_time;
+ mxf->current_klv_data = (KLVPacket){{0}};
} else {
+ MXFPartition *partition;
+
t = &mxf->index_tables[0];
if (t->index_sid != source_track->index_sid) {
/* If the first index table does not belong to the stream, then find a stream which does belong to the index table */
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)
+ if (source_track->wrapping == UnknownWrapped)
+ av_log(mxf->fc, AV_LOG_WARNING, "attempted seek in an UnknownWrapped essence\n");
+
+ if ((ret = mxf_edit_unit_absolute_offset(mxf, t, sample_time, source_track->edit_rate, &sample_time, &seekpos, &partition, 1)) < 0)
return ret;
ff_update_cur_dts(s, st, sample_time);
- mxf->current_edit_unit = sample_time;
+ if (source_track->wrapping == ClipWrapped) {
+ KLVPacket klv = partition->first_essence_klv;
+ if (seekpos < klv.next_klv - klv.length || seekpos >= klv.next_klv) {
+ av_log(mxf->fc, AV_LOG_ERROR, "attempted seek out of clip wrapped KLV\n");
+ return AVERROR_INVALIDDATA;
+ }
+ mxf->current_klv_data = klv;
+ } else {
+ mxf->current_klv_data = (KLVPacket){{0}};
+ }
avio_seek(s->pb, seekpos, SEEK_SET);
}
for (i = 0; i < s->nb_streams; i++) {
AVStream *cur_st = s->streams[i];
MXFTrack *cur_track = cur_st->priv_data;
- if (cur_st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
- int64_t track_edit_unit;
- if (st != cur_st && mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit) >= 0) {
- cur_track->sample_count = av_rescale_q(track_edit_unit,
- av_inv_q(cur_track->edit_rate),
- cur_st->time_base);
- } else {
- uint64_t current_sample_count = 0;
- ret = mxf_compute_sample_count(mxf, i, ¤t_sample_count);
- if (ret < 0)
- return ret;
- cur_track->sample_count = current_sample_count;
- }
+ if (cur_track) {
+ int64_t track_edit_unit = sample_time;
+ if (st != cur_st)
+ mxf_get_next_track_edit_unit(mxf, cur_track, seekpos, &track_edit_unit);
+ cur_track->sample_count = mxf_compute_sample_count(mxf, cur_st, track_edit_unit);
}
}
return 0;
projects / ffmpeg / blobdiff