#include "qtpalette.h"
#define EBML_UNKNOWN_LENGTH UINT64_MAX /* EBML unknown length, in uint64_t */
+#define NEEDS_CHECKING 2 /* Indicates that some error checks
+ * still need to be performed */
+#define LEVEL_ENDED 3 /* return value of ebml_parse when the
+ * syntax level used for parsing ended. */
typedef enum {
EBML_NONE,
EBML_BIN,
EBML_NEST,
EBML_LEVEL1,
- EBML_PASS,
EBML_STOP,
EBML_SINT,
EBML_TYPE_COUNT
uint64_t length;
} MatroskaLevel;
+typedef struct MatroskaBlock {
+ uint64_t duration;
+ int64_t reference;
+ uint64_t non_simple;
+ EbmlBin bin;
+ uint64_t additional_id;
+ EbmlBin additional;
+ int64_t discard_padding;
+} MatroskaBlock;
+
typedef struct MatroskaCluster {
+ MatroskaBlock block;
uint64_t timecode;
- EbmlList blocks;
+ int64_t pos;
} MatroskaCluster;
typedef struct MatroskaLevel1Element {
- uint64_t id;
uint64_t pos;
+ uint32_t id;
int parsed;
} MatroskaLevel1Element;
int num_levels;
MatroskaLevel levels[EBML_MAX_DEPTH];
uint32_t current_id;
+ int64_t resync_pos;
uint64_t time_scale;
double duration;
MatroskaLevel1Element level1_elems[64];
int num_level1_elems;
- int current_cluster_num_blocks;
- int64_t current_cluster_pos;
MatroskaCluster current_cluster;
- /* File has SSA subtitles which prevent incremental cluster parsing. */
- int contains_ssa;
-
/* WebM DASH Manifest live flag */
int is_live;
int bandwidth;
} MatroskaDemuxContext;
-typedef struct MatroskaBlock {
- uint64_t duration;
- int64_t reference;
- uint64_t non_simple;
- EbmlBin bin;
- uint64_t additional_id;
- EbmlBin additional;
- int64_t discard_padding;
-} MatroskaBlock;
+#define CHILD_OF(parent) { .def = { .n = parent } }
+
+static const EbmlSyntax ebml_syntax[], matroska_segment[], matroska_track_video_color[], matroska_track_video[],
+ matroska_track[], matroska_track_encoding[], matroska_track_encodings[],
+ matroska_track_combine_planes[], matroska_track_operation[], matroska_tracks[],
+ matroska_attachments[], matroska_chapter_entry[], matroska_chapter[], matroska_chapters[],
+ matroska_index_entry[], matroska_index[], matroska_tag[], matroska_tags[], matroska_seekhead[],
+ matroska_blockadditions[], matroska_blockgroup[], matroska_cluster_parsing[];
static const EbmlSyntax ebml_header[] = {
{ EBML_ID_EBMLREADVERSION, EBML_UINT, 0, offsetof(Ebml, version), { .u = EBML_VERSION } },
{ EBML_ID_DOCTYPEREADVERSION, EBML_UINT, 0, offsetof(Ebml, doctype_version), { .u = 1 } },
{ EBML_ID_EBMLVERSION, EBML_NONE },
{ EBML_ID_DOCTYPEVERSION, EBML_NONE },
- { 0 }
+ CHILD_OF(ebml_syntax)
};
static const EbmlSyntax ebml_syntax[] = {
- { EBML_ID_HEADER, EBML_NEST, 0, 0, { .n = ebml_header } },
+ { EBML_ID_HEADER, EBML_NEST, 0, 0, { .n = ebml_header } },
+ { MATROSKA_ID_SEGMENT, EBML_STOP },
{ 0 }
};
{ MATROSKA_ID_MUXINGAPP, EBML_UTF8, 0, offsetof(MatroskaDemuxContext, muxingapp) },
{ MATROSKA_ID_DATEUTC, EBML_BIN, 0, offsetof(MatroskaDemuxContext, date_utc) },
{ MATROSKA_ID_SEGMENTUID, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_mastering_meta[] = {
{ MATROSKA_ID_VIDEOCOLOR_WHITEY, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, white_y), { .f=-1 } },
{ MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, min_luminance), { .f=-1 } },
{ MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX, EBML_FLOAT, 0, offsetof(MatroskaMasteringMeta, max_luminance), { .f=-1 } },
- { 0 }
+ CHILD_OF(matroska_track_video_color)
};
static const EbmlSyntax matroska_track_video_color[] = {
{ MATROSKA_ID_VIDEOCOLORMAXCLL, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, max_cll), { .u=0 } },
{ MATROSKA_ID_VIDEOCOLORMAXFALL, EBML_UINT, 0, offsetof(MatroskaTrackVideoColor, max_fall), { .u=0 } },
{ MATROSKA_ID_VIDEOCOLORMASTERINGMETA, EBML_NEST, 0, offsetof(MatroskaTrackVideoColor, mastering_meta), { .n = matroska_mastering_meta } },
- { 0 }
+ CHILD_OF(matroska_track_video)
};
static const EbmlSyntax matroska_track_video_projection[] = {
{ MATROSKA_ID_VIDEOPROJECTIONPOSEYAW, EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, yaw), { .f=0.0 } },
{ MATROSKA_ID_VIDEOPROJECTIONPOSEPITCH, EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, pitch), { .f=0.0 } },
{ MATROSKA_ID_VIDEOPROJECTIONPOSEROLL, EBML_FLOAT, 0, offsetof(MatroskaTrackVideoProjection, roll), { .f=0.0 } },
- { 0 }
+ CHILD_OF(matroska_track_video)
};
static const EbmlSyntax matroska_track_video[] = {
{ MATROSKA_ID_VIDEOFIELDORDER, EBML_UINT, 0, offsetof(MatroskaTrackVideo, field_order), { .u = MATROSKA_VIDEO_FIELDORDER_UNDETERMINED } },
{ MATROSKA_ID_VIDEOSTEREOMODE, EBML_UINT, 0, offsetof(MatroskaTrackVideo, stereo_mode), { .u = MATROSKA_VIDEO_STEREOMODE_TYPE_NB } },
{ MATROSKA_ID_VIDEOASPECTRATIO, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_track)
};
static const EbmlSyntax matroska_track_audio[] = {
{ MATROSKA_ID_AUDIOOUTSAMPLINGFREQ, EBML_FLOAT, 0, offsetof(MatroskaTrackAudio, out_samplerate) },
{ MATROSKA_ID_AUDIOBITDEPTH, EBML_UINT, 0, offsetof(MatroskaTrackAudio, bitdepth) },
{ MATROSKA_ID_AUDIOCHANNELS, EBML_UINT, 0, offsetof(MatroskaTrackAudio, channels), { .u = 1 } },
- { 0 }
+ CHILD_OF(matroska_track)
};
static const EbmlSyntax matroska_track_encoding_compression[] = {
{ MATROSKA_ID_ENCODINGCOMPALGO, EBML_UINT, 0, offsetof(MatroskaTrackCompression, algo), { .u = 0 } },
{ MATROSKA_ID_ENCODINGCOMPSETTINGS, EBML_BIN, 0, offsetof(MatroskaTrackCompression, settings) },
- { 0 }
+ CHILD_OF(matroska_track_encoding)
};
static const EbmlSyntax matroska_track_encoding_encryption[] = {
{ MATROSKA_ID_ENCODINGSIGHASHALGO, EBML_NONE },
{ MATROSKA_ID_ENCODINGSIGKEYID, EBML_NONE },
{ MATROSKA_ID_ENCODINGSIGNATURE, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_track_encoding)
};
static const EbmlSyntax matroska_track_encoding[] = {
{ MATROSKA_ID_ENCODINGSCOPE, EBML_UINT, 0, offsetof(MatroskaTrackEncoding, scope), { .u = 1 } },
{ MATROSKA_ID_ENCODINGCOMPRESSION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, compression), { .n = matroska_track_encoding_compression } },
{ MATROSKA_ID_ENCODINGENCRYPTION, EBML_NEST, 0, offsetof(MatroskaTrackEncoding, encryption), { .n = matroska_track_encoding_encryption } },
{ MATROSKA_ID_ENCODINGORDER, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_track_encodings)
};
static const EbmlSyntax matroska_track_encodings[] = {
{ MATROSKA_ID_TRACKCONTENTENCODING, EBML_NEST, sizeof(MatroskaTrackEncoding), offsetof(MatroskaTrack, encodings), { .n = matroska_track_encoding } },
- { 0 }
+ CHILD_OF(matroska_track)
};
static const EbmlSyntax matroska_track_plane[] = {
{ MATROSKA_ID_TRACKPLANEUID, EBML_UINT, 0, offsetof(MatroskaTrackPlane,uid) },
{ MATROSKA_ID_TRACKPLANETYPE, EBML_UINT, 0, offsetof(MatroskaTrackPlane,type) },
- { 0 }
+ CHILD_OF(matroska_track_combine_planes)
};
static const EbmlSyntax matroska_track_combine_planes[] = {
{ MATROSKA_ID_TRACKPLANE, EBML_NEST, sizeof(MatroskaTrackPlane), offsetof(MatroskaTrackOperation,combine_planes), {.n = matroska_track_plane} },
- { 0 }
+ CHILD_OF(matroska_track_operation)
};
static const EbmlSyntax matroska_track_operation[] = {
{ MATROSKA_ID_TRACKCOMBINEPLANES, EBML_NEST, 0, 0, {.n = matroska_track_combine_planes} },
- { 0 }
+ CHILD_OF(matroska_track)
};
static const EbmlSyntax matroska_track[] = {
{ MATROSKA_ID_CODECDOWNLOADURL, EBML_NONE },
{ MATROSKA_ID_TRACKMINCACHE, EBML_NONE },
{ MATROSKA_ID_TRACKMAXCACHE, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_tracks)
};
static const EbmlSyntax matroska_tracks[] = {
{ MATROSKA_ID_TRACKENTRY, EBML_NEST, sizeof(MatroskaTrack), offsetof(MatroskaDemuxContext, tracks), { .n = matroska_track } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_attachment[] = {
{ MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachment, mime) },
{ MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachment, bin) },
{ MATROSKA_ID_FILEDESC, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_attachments)
};
static const EbmlSyntax matroska_attachments[] = {
{ MATROSKA_ID_ATTACHEDFILE, EBML_NEST, sizeof(MatroskaAttachment), offsetof(MatroskaDemuxContext, attachments), { .n = matroska_attachment } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_chapter_display[] = {
{ MATROSKA_ID_CHAPSTRING, EBML_UTF8, 0, offsetof(MatroskaChapter, title) },
{ MATROSKA_ID_CHAPLANG, EBML_NONE },
{ MATROSKA_ID_CHAPCOUNTRY, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_chapter_entry)
};
static const EbmlSyntax matroska_chapter_entry[] = {
{ MATROSKA_ID_CHAPTERFLAGENABLED, EBML_NONE },
{ MATROSKA_ID_CHAPTERPHYSEQUIV, EBML_NONE },
{ MATROSKA_ID_CHAPTERATOM, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_chapter)
};
static const EbmlSyntax matroska_chapter[] = {
{ MATROSKA_ID_EDITIONFLAGHIDDEN, EBML_NONE },
{ MATROSKA_ID_EDITIONFLAGDEFAULT, EBML_NONE },
{ MATROSKA_ID_EDITIONFLAGORDERED, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_chapters)
};
static const EbmlSyntax matroska_chapters[] = {
{ MATROSKA_ID_EDITIONENTRY, EBML_NEST, 0, 0, { .n = matroska_chapter } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_index_pos[] = {
{ MATROSKA_ID_CUERELATIVEPOSITION,EBML_NONE },
{ MATROSKA_ID_CUEDURATION, EBML_NONE },
{ MATROSKA_ID_CUEBLOCKNUMBER, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_index_entry)
};
static const EbmlSyntax matroska_index_entry[] = {
{ MATROSKA_ID_CUETIME, EBML_UINT, 0, offsetof(MatroskaIndex, time) },
{ MATROSKA_ID_CUETRACKPOSITION, EBML_NEST, sizeof(MatroskaIndexPos), offsetof(MatroskaIndex, pos), { .n = matroska_index_pos } },
- { 0 }
+ CHILD_OF(matroska_index)
};
static const EbmlSyntax matroska_index[] = {
{ MATROSKA_ID_POINTENTRY, EBML_NEST, sizeof(MatroskaIndex), offsetof(MatroskaDemuxContext, index), { .n = matroska_index_entry } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_simpletag[] = {
{ MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTag, def) },
{ MATROSKA_ID_TAGDEFAULT_BUG, EBML_UINT, 0, offsetof(MatroskaTag, def) },
{ MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag, sub), { .n = matroska_simpletag } },
- { 0 }
+ CHILD_OF(matroska_tag)
};
static const EbmlSyntax matroska_tagtargets[] = {
{ MATROSKA_ID_TAGTARGETS_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, trackuid) },
{ MATROSKA_ID_TAGTARGETS_CHAPTERUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, chapteruid) },
{ MATROSKA_ID_TAGTARGETS_ATTACHUID, EBML_UINT, 0, offsetof(MatroskaTagTarget, attachuid) },
- { 0 }
+ CHILD_OF(matroska_tag)
};
static const EbmlSyntax matroska_tag[] = {
{ MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTags, tag), { .n = matroska_simpletag } },
{ MATROSKA_ID_TAGTARGETS, EBML_NEST, 0, offsetof(MatroskaTags, target), { .n = matroska_tagtargets } },
- { 0 }
+ CHILD_OF(matroska_tags)
};
static const EbmlSyntax matroska_tags[] = {
{ MATROSKA_ID_TAG, EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext, tags), { .n = matroska_tag } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_seekhead_entry[] = {
{ MATROSKA_ID_SEEKID, EBML_UINT, 0, offsetof(MatroskaSeekhead, id) },
{ MATROSKA_ID_SEEKPOSITION, EBML_UINT, 0, offsetof(MatroskaSeekhead, pos), { .u = -1 } },
- { 0 }
+ CHILD_OF(matroska_seekhead)
};
static const EbmlSyntax matroska_seekhead[] = {
{ MATROSKA_ID_SEEKENTRY, EBML_NEST, sizeof(MatroskaSeekhead), offsetof(MatroskaDemuxContext, seekhead), { .n = matroska_seekhead_entry } },
- { 0 }
+ CHILD_OF(matroska_segment)
};
static const EbmlSyntax matroska_segment[] = {
{ MATROSKA_ID_TAGS, EBML_LEVEL1, 0, 0, { .n = matroska_tags } },
{ MATROSKA_ID_SEEKHEAD, EBML_LEVEL1, 0, 0, { .n = matroska_seekhead } },
{ MATROSKA_ID_CLUSTER, EBML_STOP },
- { 0 }
+ { 0 } /* We don't want to go back to level 0, so don't add the parent. */
};
static const EbmlSyntax matroska_segments[] = {
static const EbmlSyntax matroska_blockmore[] = {
{ MATROSKA_ID_BLOCKADDID, EBML_UINT, 0, offsetof(MatroskaBlock,additional_id) },
{ MATROSKA_ID_BLOCKADDITIONAL, EBML_BIN, 0, offsetof(MatroskaBlock,additional) },
- { 0 }
+ CHILD_OF(matroska_blockadditions)
};
static const EbmlSyntax matroska_blockadditions[] = {
{ MATROSKA_ID_BLOCKMORE, EBML_NEST, 0, 0, {.n = matroska_blockmore} },
- { 0 }
+ CHILD_OF(matroska_blockgroup)
};
static const EbmlSyntax matroska_blockgroup[] = {
{ MATROSKA_ID_BLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
{ MATROSKA_ID_BLOCKADDITIONS, EBML_NEST, 0, 0, { .n = matroska_blockadditions} },
- { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
{ MATROSKA_ID_BLOCKDURATION, EBML_UINT, 0, offsetof(MatroskaBlock, duration) },
{ MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, offsetof(MatroskaBlock, discard_padding) },
{ MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, offsetof(MatroskaBlock, reference), { .i = INT64_MIN } },
{ MATROSKA_ID_CODECSTATE, EBML_NONE },
{ 1, EBML_UINT, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
- { 0 }
+ CHILD_OF(matroska_cluster_parsing)
};
-static const EbmlSyntax matroska_cluster[] = {
- { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
- { MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
- { MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
- { MATROSKA_ID_CLUSTERPOSITION, EBML_NONE },
- { MATROSKA_ID_CLUSTERPREVSIZE, EBML_NONE },
- { 0 }
-};
-
-static const EbmlSyntax matroska_clusters[] = {
- { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = matroska_cluster } },
- { MATROSKA_ID_INFO, EBML_NONE },
- { MATROSKA_ID_CUES, EBML_NONE },
- { MATROSKA_ID_TAGS, EBML_NONE },
- { MATROSKA_ID_SEEKHEAD, EBML_NONE },
- { 0 }
-};
-
-static const EbmlSyntax matroska_cluster_incremental_parsing[] = {
- { MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
- { MATROSKA_ID_BLOCKGROUP, EBML_NEST, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
- { MATROSKA_ID_SIMPLEBLOCK, EBML_PASS, sizeof(MatroskaBlock), offsetof(MatroskaCluster, blocks), { .n = matroska_blockgroup } },
- { MATROSKA_ID_CLUSTERPOSITION, EBML_NONE },
- { MATROSKA_ID_CLUSTERPREVSIZE, EBML_NONE },
- { MATROSKA_ID_INFO, EBML_NONE },
- { MATROSKA_ID_CUES, EBML_NONE },
- { MATROSKA_ID_TAGS, EBML_NONE },
- { MATROSKA_ID_SEEKHEAD, EBML_NONE },
- { MATROSKA_ID_CLUSTER, EBML_STOP },
- { 0 }
-};
-
-static const EbmlSyntax matroska_cluster_incremental[] = {
+// The following array contains SimpleBlock and BlockGroup twice
+// in order to reuse the other values for matroska_cluster_enter.
+static const EbmlSyntax matroska_cluster_parsing[] = {
+ { MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock, bin) },
+ { MATROSKA_ID_BLOCKGROUP, EBML_NEST, 0, 0, { .n = matroska_blockgroup } },
{ MATROSKA_ID_CLUSTERTIMECODE, EBML_UINT, 0, offsetof(MatroskaCluster, timecode) },
- { MATROSKA_ID_BLOCKGROUP, EBML_STOP },
{ MATROSKA_ID_SIMPLEBLOCK, EBML_STOP },
+ { MATROSKA_ID_BLOCKGROUP, EBML_STOP },
{ MATROSKA_ID_CLUSTERPOSITION, EBML_NONE },
{ MATROSKA_ID_CLUSTERPREVSIZE, EBML_NONE },
- { 0 }
+ CHILD_OF(matroska_segment)
};
-static const EbmlSyntax matroska_clusters_incremental[] = {
- { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = matroska_cluster_incremental } },
- { MATROSKA_ID_INFO, EBML_NONE },
- { MATROSKA_ID_CUES, EBML_NONE },
- { MATROSKA_ID_TAGS, EBML_NONE },
- { MATROSKA_ID_SEEKHEAD, EBML_NONE },
+static const EbmlSyntax matroska_cluster_enter[] = {
+ { MATROSKA_ID_CLUSTER, EBML_NEST, 0, 0, { .n = &matroska_cluster_parsing[2] } },
{ 0 }
};
+static const EbmlSyntax matroska_clusters[] = {
+ { MATROSKA_ID_CLUSTER, EBML_STOP },
+ { MATROSKA_ID_CUES, EBML_NONE },
+ { MATROSKA_ID_TAGS, EBML_NONE },
+ { MATROSKA_ID_INFO, EBML_NONE },
+ { MATROSKA_ID_TRACKS, EBML_NONE },
+ { MATROSKA_ID_ATTACHMENTS, EBML_NONE },
+ { MATROSKA_ID_CHAPTERS, EBML_NONE },
+ { MATROSKA_ID_SEEKHEAD, EBML_NONE },
+ { 0 } /* We don't want to go back to level 0, so don't add the parent. */
+};
+#undef CHILD_OF
+
static const char *const matroska_doctypes[] = { "matroska", "webm" };
static int matroska_read_close(AVFormatContext *s);
+/*
+ * This function prepares the status for parsing of level 1 elements.
+ */
+static int matroska_reset_status(MatroskaDemuxContext *matroska,
+ uint32_t id, int64_t position)
+{
+ if (position >= 0) {
+ int err = avio_seek(matroska->ctx->pb, position, SEEK_SET);
+ if (err < 0)
+ return err;
+ }
+
+ matroska->current_id = id;
+ matroska->num_levels = 1;
+ matroska->resync_pos = avio_tell(matroska->ctx->pb);
+ if (id)
+ matroska->resync_pos -= (av_log2(id) + 7) / 8;
+
+ return 0;
+}
+
static int matroska_resync(MatroskaDemuxContext *matroska, int64_t last_pos)
{
AVIOContext *pb = matroska->ctx->pb;
- int64_t ret;
uint32_t id;
- matroska->current_id = 0;
- matroska->num_levels = 0;
- /* seek to next position to resync from */
- if ((ret = avio_seek(pb, last_pos + 1, SEEK_SET)) < 0) {
- matroska->done = 1;
- return ret;
+ /* Try to seek to the last position to resync from. If this doesn't work,
+ * we resync from the earliest position available: The start of the buffer. */
+ if (last_pos < avio_tell(pb) && avio_seek(pb, last_pos + 1, SEEK_SET) < 0) {
+ av_log(matroska->ctx, AV_LOG_WARNING,
+ "Seek to desired resync point failed. Seeking to "
+ "earliest point available instead.\n");
+ avio_seek(pb, FFMAX(avio_tell(pb) + (pb->buffer - pb->buf_ptr),
+ last_pos + 1), SEEK_SET);
}
id = avio_rb32(pb);
id == MATROSKA_ID_CUES || id == MATROSKA_ID_TAGS ||
id == MATROSKA_ID_SEEKHEAD || id == MATROSKA_ID_ATTACHMENTS ||
id == MATROSKA_ID_CLUSTER || id == MATROSKA_ID_CHAPTERS) {
- matroska->current_id = id;
+ /* Prepare the context for parsing of a level 1 element. */
+ matroska_reset_status(matroska, id, -1);
+ /* Given that we are here means that an error has occured,
+ * so treat the segment as unknown length in order not to
+ * discard valid data that happens to be beyond the designated
+ * end of the segment. */
+ matroska->levels[0].length = EBML_UNKNOWN_LENGTH;
return 0;
}
id = (id << 8) | avio_r8(pb);
}
matroska->done = 1;
- return AVERROR_EOF;
-}
-
-/*
- * Return: Whether we reached the end of a level in the hierarchy or not.
- */
-static int ebml_level_end(MatroskaDemuxContext *matroska)
-{
- AVIOContext *pb = matroska->ctx->pb;
- int64_t pos = avio_tell(pb);
-
- if (matroska->num_levels > 0) {
- MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
- if (pos - level->start >= level->length || matroska->current_id) {
- matroska->num_levels--;
- return 1;
- }
- }
- return (matroska->is_live && matroska->ctx->pb->eof_reached) ? 1 : 0;
+ return pb->error ? pb->error : AVERROR_EOF;
}
/*
* Returns: number of bytes read, < 0 on error
*/
static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
- int max_size, uint64_t *number)
+ int max_size, uint64_t *number, int eof_forbidden)
{
- int read = 1, n = 1;
- uint64_t total = 0;
+ int read, n = 1;
+ uint64_t total;
+ int64_t pos;
- /* The first byte tells us the length in bytes - avio_r8() can normally
- * return 0, but since that's not a valid first ebmlID byte, we can
- * use it safely here to catch EOS. */
- if (!(total = avio_r8(pb))) {
- /* we might encounter EOS here */
- if (!avio_feof(pb)) {
- int64_t pos = avio_tell(pb);
- av_log(matroska->ctx, AV_LOG_ERROR,
- "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
- pos, pos);
- return pb->error ? pb->error : AVERROR(EIO);
- }
- return AVERROR_EOF;
- }
+ /* The first byte tells us the length in bytes - except when it is zero. */
+ total = avio_r8(pb);
+ if (pb->eof_reached)
+ goto err;
/* get the length of the EBML number */
read = 8 - ff_log2_tab[total];
- if (read > max_size) {
- int64_t pos = avio_tell(pb) - 1;
- av_log(matroska->ctx, AV_LOG_ERROR,
- "Invalid EBML number size tag 0x%02x at pos %"PRIu64" (0x%"PRIx64")\n",
- (uint8_t) total, pos, pos);
+
+ if (!total || read > max_size) {
+ pos = avio_tell(pb) - 1;
+ if (!total) {
+ av_log(matroska->ctx, AV_LOG_ERROR,
+ "0x00 at pos %"PRId64" (0x%"PRIx64") invalid as first byte "
+ "of an EBML number\n", pos, pos);
+ } else {
+ av_log(matroska->ctx, AV_LOG_ERROR,
+ "Length %d indicated by an EBML number's first byte 0x%02x "
+ "at pos %"PRId64" (0x%"PRIx64") exceeds max length %d.\n",
+ read, (uint8_t) total, pos, pos, max_size);
+ }
return AVERROR_INVALIDDATA;
}
while (n++ < read)
total = (total << 8) | avio_r8(pb);
+ if (pb->eof_reached) {
+ eof_forbidden = 1;
+ goto err;
+ }
+
*number = total;
return read;
+
+err:
+ pos = avio_tell(pb);
+ if (pb->error) {
+ av_log(matroska->ctx, AV_LOG_ERROR,
+ "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
+ pos, pos);
+ return pb->error;
+ }
+ if (eof_forbidden) {
+ av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely "
+ "at pos. %"PRIu64" (0x%"PRIx64")\n", pos, pos);
+ return AVERROR(EIO);
+ }
+ return AVERROR_EOF;
}
/**
static int ebml_read_length(MatroskaDemuxContext *matroska, AVIOContext *pb,
uint64_t *number)
{
- int res = ebml_read_num(matroska, pb, 8, number);
+ int res = ebml_read_num(matroska, pb, 8, number, 1);
if (res > 0 && *number + 1 == 1ULL << (7 * res))
*number = EBML_UNKNOWN_LENGTH;
return res;
/*
* Read the next element as an unsigned int.
- * 0 is success, < 0 is failure.
+ * Returns NEEDS_CHECKING.
*/
static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
{
int n = 0;
- if (size > 8)
- return AVERROR_INVALIDDATA;
-
/* big-endian ordering; build up number */
*num = 0;
while (n++ < size)
*num = (*num << 8) | avio_r8(pb);
- return 0;
+ return NEEDS_CHECKING;
}
/*
* Read the next element as a signed int.
- * 0 is success, < 0 is failure.
+ * Returns NEEDS_CHECKING.
*/
static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
{
int n = 1;
- if (size > 8)
- return AVERROR_INVALIDDATA;
-
if (size == 0) {
*num = 0;
} else {
*num = ((uint64_t)*num << 8) | avio_r8(pb);
}
- return 0;
+ return NEEDS_CHECKING;
}
/*
* Read the next element as a float.
- * 0 is success, < 0 is failure.
+ * Returns NEEDS_CHECKING or < 0 on obvious failure.
*/
static int ebml_read_float(AVIOContext *pb, int size, double *num)
{
else
return AVERROR_INVALIDDATA;
- return 0;
+ return NEEDS_CHECKING;
}
/*
* Read the next element as an ASCII string.
- * 0 is success, < 0 is failure.
+ * 0 is success, < 0 or NEEDS_CHECKING is failure.
*/
static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
{
char *res;
+ int ret;
/* EBML strings are usually not 0-terminated, so we allocate one
* byte more, read the string and NULL-terminate it ourselves. */
if (!(res = av_malloc(size + 1)))
return AVERROR(ENOMEM);
- if (avio_read(pb, (uint8_t *) res, size) != size) {
+ if ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
av_free(res);
- return AVERROR(EIO);
+ return ret < 0 ? ret : NEEDS_CHECKING;
}
(res)[size] = '\0';
av_free(*str);
/*
* Read the next element as binary data.
- * 0 is success, < 0 is failure.
+ * 0 is success, < 0 or NEEDS_CHECKING is failure.
*/
static int ebml_read_binary(AVIOContext *pb, int length, EbmlBin *bin)
{
bin->data = bin->buf->data;
bin->size = length;
bin->pos = avio_tell(pb);
- if (avio_read(pb, bin->data, length) != length) {
+ if ((ret = avio_read(pb, bin->data, length)) != length) {
av_buffer_unref(&bin->buf);
bin->data = NULL;
bin->size = 0;
- return AVERROR(EIO);
+ return ret < 0 ? ret : NEEDS_CHECKING;
}
return 0;
{
AVIOContext pb;
ffio_init_context(&pb, data, size, 0, NULL, NULL, NULL, NULL);
- return ebml_read_num(matroska, &pb, FFMIN(size, 8), num);
+ return ebml_read_num(matroska, &pb, FFMIN(size, 8), num, 1);
}
/*
return res;
}
-static int ebml_parse_elem(MatroskaDemuxContext *matroska,
- EbmlSyntax *syntax, void *data);
+static int ebml_parse(MatroskaDemuxContext *matroska,
+ EbmlSyntax *syntax, void *data);
-static int ebml_parse_id(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
- uint32_t id, void *data)
+static EbmlSyntax *ebml_parse_id(EbmlSyntax *syntax, uint32_t id)
{
int i;
+
+ // Whoever touches this should be aware of the duplication
+ // existing in matroska_cluster_parsing.
for (i = 0; syntax[i].id; i++)
if (id == syntax[i].id)
break;
- if (!syntax[i].id && id == MATROSKA_ID_CLUSTER &&
- matroska->num_levels > 0 &&
- matroska->levels[matroska->num_levels - 1].length == EBML_UNKNOWN_LENGTH)
- return 0; // we reached the end of an unknown size cluster
- if (!syntax[i].id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
- av_log(matroska->ctx, AV_LOG_DEBUG, "Unknown entry 0x%"PRIX32"\n", id);
- }
- return ebml_parse_elem(matroska, &syntax[i], data);
-}
-static int ebml_parse(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
- void *data)
-{
- if (!matroska->current_id) {
- uint64_t id;
- int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
- if (res < 0) {
- // in live mode, finish parsing if EOF is reached.
- return (matroska->is_live && matroska->ctx->pb->eof_reached &&
- res == AVERROR_EOF) ? 1 : res;
- }
- matroska->current_id = id | 1 << 7 * res;
- }
- return ebml_parse_id(matroska, syntax, matroska->current_id, data);
+ return &syntax[i];
}
static int ebml_parse_nest(MatroskaDemuxContext *matroska, EbmlSyntax *syntax,
void *data)
{
- int i, res = 0;
+ int i, res;
for (i = 0; syntax[i].id; i++)
switch (syntax[i].type) {
break;
}
- while (!res && !ebml_level_end(matroska))
+ if (!matroska->levels[matroska->num_levels - 1].length) {
+ matroska->num_levels--;
+ return 0;
+ }
+
+ do {
res = ebml_parse(matroska, syntax, data);
+ } while (!res);
- return res;
+ return res == LEVEL_ENDED ? 0 : res;
}
static int is_ebml_id_valid(uint32_t id)
return elem;
}
-static int ebml_parse_elem(MatroskaDemuxContext *matroska,
- EbmlSyntax *syntax, void *data)
+static int ebml_parse(MatroskaDemuxContext *matroska,
+ EbmlSyntax *syntax, void *data)
{
static const uint64_t max_lengths[EBML_TYPE_COUNT] = {
[EBML_UINT] = 8,
+ [EBML_SINT] = 8,
[EBML_FLOAT] = 8,
// max. 16 MB for strings
[EBML_STR] = 0x1000000,
// no limits for anything else
};
AVIOContext *pb = matroska->ctx->pb;
- uint32_t id = syntax->id;
+ uint32_t id;
uint64_t length;
- int res;
+ int64_t pos = avio_tell(pb);
+ int res, update_pos = 1, level_check;
void *newelem;
MatroskaLevel1Element *level1_elem;
+ MatroskaLevel *level = matroska->num_levels ? &matroska->levels[matroska->num_levels - 1] : NULL;
+
+ if (!matroska->current_id) {
+ uint64_t id;
+ res = ebml_read_num(matroska, pb, 4, &id, 0);
+ if (res < 0) {
+ if (pb->eof_reached && res == AVERROR_EOF) {
+ if (matroska->is_live)
+ // in live mode, finish parsing if EOF is reached.
+ return 1;
+ if (level && level->length == EBML_UNKNOWN_LENGTH && pos == avio_tell(pb)) {
+ // Unknown-length levels automatically end at EOF.
+ matroska->num_levels--;
+ return LEVEL_ENDED;
+ }
+ }
+ return res;
+ }
+ matroska->current_id = id | 1 << 7 * res;
+ } else
+ pos -= (av_log2(matroska->current_id) + 7) / 8;
+
+ id = matroska->current_id;
+
+ syntax = ebml_parse_id(syntax, id);
+ if (!syntax->id && id != EBML_ID_VOID && id != EBML_ID_CRC32) {
+ if (level && level->length == EBML_UNKNOWN_LENGTH) {
+ // Unknown-length levels end when an element from an upper level
+ // in the hierarchy is encountered.
+ while (syntax->def.n) {
+ syntax = ebml_parse_id(syntax->def.n, id);
+ if (syntax->id) {
+ matroska->num_levels--;
+ return LEVEL_ENDED;
+ }
+ };
+ }
+
+ av_log(matroska->ctx, AV_LOG_DEBUG, "Unknown entry 0x%"PRIX32" at pos. "
+ "%"PRId64"\n", id, pos);
+ update_pos = 0; /* Don't update resync_pos as an error might have happened. */
+ }
data = (char *) data + syntax->data_offset;
if (syntax->list_elem_size) {
list->nb_elem++;
}
- if (syntax->type != EBML_PASS && syntax->type != EBML_STOP) {
+ if (syntax->type != EBML_STOP) {
matroska->current_id = 0;
if ((res = ebml_read_length(matroska, pb, &length)) < 0)
return res;
uint64_t elem_end = pos + length,
level_end = level->start + level->length;
- if (level_end < elem_end) {
+ if (elem_end < level_end) {
+ level_check = 0;
+ } else if (elem_end == level_end) {
+ level_check = LEVEL_ENDED;
+ } else {
av_log(matroska->ctx, AV_LOG_ERROR,
"Element at 0x%"PRIx64" ending at 0x%"PRIx64" exceeds "
"containing master element ending at 0x%"PRIx64"\n",
pos, elem_end, level_end);
return AVERROR_INVALIDDATA;
}
+ } else if (length != EBML_UNKNOWN_LENGTH) {
+ level_check = 0;
} else if (level->length != EBML_UNKNOWN_LENGTH) {
av_log(matroska->ctx, AV_LOG_ERROR, "Unknown-sized element "
"at 0x%"PRIx64" inside parent with finite size\n", pos);
return AVERROR_INVALIDDATA;
- } else if (length == EBML_UNKNOWN_LENGTH && id != MATROSKA_ID_CLUSTER) {
+ } else if (id != MATROSKA_ID_CLUSTER) {
// According to the specifications only clusters and segments
// are allowed to be unknown-sized.
av_log(matroska->ctx, AV_LOG_ERROR,
"Found unknown-sized element other than a cluster at "
"0x%"PRIx64". Dropping the invalid element.\n", pos);
return AVERROR_INVALIDDATA;
- }
+ } else
+ level_check = 0;
+ } else
+ level_check = 0;
+
+ if (update_pos) {
+ // We have found an element that is allowed at this place
+ // in the hierarchy and it passed all checks, so treat the beginning
+ // of the element as the "last known good" position.
+ matroska->resync_pos = pos;
}
}
av_log(matroska->ctx, AV_LOG_ERROR, "Duplicate element\n");
level1_elem->parsed = 1;
}
- return ebml_parse_nest(matroska, syntax->def.n, data);
- case EBML_PASS:
- return ebml_parse_id(matroska, syntax->def.n, id, data);
+ if (res = ebml_parse_nest(matroska, syntax->def.n, data))
+ return res;
+ break;
case EBML_STOP:
return 1;
default:
- if (ffio_limit(pb, length) != length)
- return AVERROR(EIO);
- return avio_skip(pb, length) < 0 ? AVERROR(EIO) : 0;
- }
- if (res == AVERROR_INVALIDDATA)
- av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
- else if (res == AVERROR(EIO))
- av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
- return res;
+ if (length) {
+ int64_t res2;
+ if (ffio_limit(pb, length) != length) {
+ // ffio_limit emits its own error message,
+ // so we don't have to.
+ return AVERROR(EIO);
+ }
+ if ((res2 = avio_skip(pb, length - 1)) >= 0) {
+ // avio_skip might take us past EOF. We check for this
+ // by skipping only length - 1 bytes, reading a byte and
+ // checking the error flags. This is done in order to check
+ // that the element has been properly skipped even when
+ // no filesize (that ffio_limit relies on) is available.
+ avio_r8(pb);
+ res = NEEDS_CHECKING;
+ } else
+ res = res2;
+ } else
+ res = 0;
+ }
+ if (res) {
+ if (res == NEEDS_CHECKING) {
+ if (pb->eof_reached) {
+ if (pb->error)
+ res = pb->error;
+ else
+ res = AVERROR_EOF;
+ } else
+ goto level_check;
+ }
+
+ if (res == AVERROR_INVALIDDATA)
+ av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
+ else if (res == AVERROR(EIO))
+ av_log(matroska->ctx, AV_LOG_ERROR, "Read error\n");
+ else if (res == AVERROR_EOF) {
+ av_log(matroska->ctx, AV_LOG_ERROR, "File ended prematurely\n");
+ res = AVERROR(EIO);
+ }
+
+ return res;
+ }
+
+level_check:
+ if (level_check == LEVEL_ENDED && matroska->num_levels) {
+ level = &matroska->levels[matroska->num_levels - 1];
+ pos = avio_tell(pb);
+
+ // Given that pos >= level->start no check for
+ // level->length != EBML_UNKNOWN_LENGTH is necessary.
+ while (matroska->num_levels && pos == level->start + level->length) {
+ matroska->num_levels--;
+ level--;
+ }
+ }
+
+ return level_check;
}
static void ebml_free(EbmlSyntax *syntax, void *data)
matroska->current_id = 0;
ret = ebml_parse(matroska, matroska_segment, matroska);
-
- /* remove dummy level */
- while (matroska->num_levels) {
- uint64_t length = matroska->levels[--matroska->num_levels].length;
- if (length == EBML_UNKNOWN_LENGTH)
- break;
+ if (ret == LEVEL_ENDED) {
+ /* This can only happen if the seek brought us beyond EOF. */
+ ret = AVERROR_EOF;
}
}
}
- /* seek back */
- avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
- matroska->current_id = saved_id;
+ /* Seek back - notice that in all instances where this is used
+ * it is safe to set the level to 1. */
+ matroska_reset_status(matroska, saved_id, before_pos);
return ret;
}
}
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
- if (st->codecpar->codec_id == AV_CODEC_ID_ASS)
- matroska->contains_ssa = 1;
}
}
pos = avio_tell(matroska->ctx->pb);
res = ebml_parse(matroska, matroska_segment, matroska);
}
+ /* Set data_offset as it might be needed later by seek_frame_generic. */
+ if (matroska->current_id == MATROSKA_ID_CLUSTER)
+ s->internal->data_offset = avio_tell(matroska->ctx->pb) - 4;
matroska_execute_seekhead(matroska);
if (!matroska->time_scale)
attachments[j].stream = st;
if (st->codecpar->codec_id != AV_CODEC_ID_NONE) {
+ AVPacket *pkt = &st->attached_pic;
+
st->disposition |= AV_DISPOSITION_ATTACHED_PIC;
st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
- av_init_packet(&st->attached_pic);
- if ((res = av_new_packet(&st->attached_pic, attachments[j].bin.size)) < 0)
- return res;
- memcpy(st->attached_pic.data, attachments[j].bin.data, attachments[j].bin.size);
- st->attached_pic.stream_index = st->index;
- st->attached_pic.flags |= AV_PKT_FLAG_KEY;
+ av_init_packet(pkt);
+ pkt->buf = av_buffer_ref(attachments[j].bin.buf);
+ if (!pkt->buf)
+ return AVERROR(ENOMEM);
+ pkt->data = attachments[j].bin.data;
+ pkt->size = attachments[j].bin.size;
+ pkt->stream_index = st->index;
+ pkt->flags |= AV_PKT_FLAG_KEY;
} else {
st->codecpar->codec_type = AVMEDIA_TYPE_ATTACHMENT;
if (ff_alloc_extradata(st->codecpar, attachments[j].bin.size))
if (!type) {
*laces = 1;
- *lace_buf = av_mallocz(sizeof(int));
+ *lace_buf = av_malloc(sizeof(**lace_buf));
if (!*lace_buf)
return AVERROR(ENOMEM);
*laces = *data + 1;
data += 1;
size -= 1;
- lace_size = av_mallocz(*laces * sizeof(int));
+ lace_size = av_malloc_array(*laces, sizeof(*lace_size));
if (!lace_size)
return AVERROR(ENOMEM);
uint8_t temp;
uint32_t total = 0;
for (n = 0; res == 0 && n < *laces - 1; n++) {
+ lace_size[n] = 0;
+
while (1) {
if (size <= total) {
res = AVERROR_INVALIDDATA;
int trust_default_duration = 1;
if ((n = matroska_ebmlnum_uint(matroska, data, size, &num)) < 0) {
- av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");
return n;
}
data += n;
return res;
}
-static int matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska)
+static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
{
- EbmlList *blocks_list;
- MatroskaBlock *blocks;
- int i, res;
- res = ebml_parse(matroska,
- matroska_cluster_incremental_parsing,
- &matroska->current_cluster);
- if (res == 1) {
- /* New Cluster */
- if (matroska->current_cluster_pos)
- ebml_level_end(matroska);
- ebml_free(matroska_cluster, &matroska->current_cluster);
- memset(&matroska->current_cluster, 0, sizeof(MatroskaCluster));
- matroska->current_cluster_num_blocks = 0;
- matroska->current_cluster_pos = avio_tell(matroska->ctx->pb);
- /* sizeof the ID which was already read */
- if (matroska->current_id)
- matroska->current_cluster_pos -= 4;
- res = ebml_parse(matroska,
- matroska_clusters_incremental,
- &matroska->current_cluster);
- /* Try parsing the block again. */
- if (res == 1)
- res = ebml_parse(matroska,
- matroska_cluster_incremental_parsing,
- &matroska->current_cluster);
- }
-
- if (!res &&
- matroska->current_cluster_num_blocks <
- matroska->current_cluster.blocks.nb_elem) {
- blocks_list = &matroska->current_cluster.blocks;
- blocks = blocks_list->elem;
-
- matroska->current_cluster_num_blocks = blocks_list->nb_elem;
- i = blocks_list->nb_elem - 1;
- if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
- int is_keyframe = blocks[i].non_simple ? blocks[i].reference == INT64_MIN : -1;
- uint8_t* additional = blocks[i].additional.size > 0 ?
- blocks[i].additional.data : NULL;
- if (!blocks[i].non_simple)
- blocks[i].duration = 0;
- res = matroska_parse_block(matroska, blocks[i].bin.buf, blocks[i].bin.data,
- blocks[i].bin.size, blocks[i].bin.pos,
- matroska->current_cluster.timecode,
- blocks[i].duration, is_keyframe,
- additional, blocks[i].additional_id,
- blocks[i].additional.size,
- matroska->current_cluster_pos,
- blocks[i].discard_padding);
+ MatroskaCluster *cluster = &matroska->current_cluster;
+ MatroskaBlock *block = &cluster->block;
+ int res;
+
+ av_assert0(matroska->num_levels <= 2);
+
+ if (matroska->num_levels == 1) {
+ res = ebml_parse(matroska, matroska_clusters, NULL);
+
+ if (res == 1) {
+ /* Found a cluster: subtract the size of the ID already read. */
+ cluster->pos = avio_tell(matroska->ctx->pb) - 4;
+
+ res = ebml_parse(matroska, matroska_cluster_enter, cluster);
+ if (res < 0)
+ return res;
}
}
- return res;
-}
+ if (matroska->num_levels == 2) {
+ /* We are inside a cluster. */
+ res = ebml_parse(matroska, matroska_cluster_parsing, cluster);
+
+ if (res >= 0 && block->bin.size > 0) {
+ int is_keyframe = block->non_simple ? block->reference == INT64_MIN : -1;
+ uint8_t* additional = block->additional.size > 0 ?
+ block->additional.data : NULL;
+
+ res = matroska_parse_block(matroska, block->bin.buf, block->bin.data,
+ block->bin.size, block->bin.pos,
+ cluster->timecode, block->duration,
+ is_keyframe, additional, block->additional_id,
+ block->additional.size, cluster->pos,
+ block->discard_padding);
+ }
-static int matroska_parse_cluster(MatroskaDemuxContext *matroska)
-{
- MatroskaCluster cluster = { 0 };
- EbmlList *blocks_list;
- MatroskaBlock *blocks;
- int i, res;
- int64_t pos;
+ ebml_free(matroska_blockgroup, block);
+ memset(block, 0, sizeof(*block));
+ } else if (!matroska->num_levels) {
+ matroska->done = 1;
+ return AVERROR_EOF;
+ }
- if (!matroska->contains_ssa)
- return matroska_parse_cluster_incremental(matroska);
- pos = avio_tell(matroska->ctx->pb);
- if (matroska->current_id)
- pos -= 4; /* sizeof the ID which was already read */
- res = ebml_parse(matroska, matroska_clusters, &cluster);
- blocks_list = &cluster.blocks;
- blocks = blocks_list->elem;
- for (i = 0; i < blocks_list->nb_elem; i++)
- if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
- int is_keyframe = blocks[i].non_simple ? blocks[i].reference == INT64_MIN : -1;
- res = matroska_parse_block(matroska, blocks[i].bin.buf, blocks[i].bin.data,
- blocks[i].bin.size, blocks[i].bin.pos,
- cluster.timecode, blocks[i].duration,
- is_keyframe, NULL, 0, 0, pos,
- blocks[i].discard_padding);
- }
- ebml_free(matroska_cluster, &cluster);
return res;
}
MatroskaDemuxContext *matroska = s->priv_data;
int ret = 0;
+ if (matroska->resync_pos == -1) {
+ // This can only happen if generic seeking has been used.
+ matroska->resync_pos = avio_tell(s->pb);
+ }
+
while (matroska_deliver_packet(matroska, pkt)) {
- int64_t pos = avio_tell(matroska->ctx->pb);
if (matroska->done)
return (ret < 0) ? ret : AVERROR_EOF;
if (matroska_parse_cluster(matroska) < 0)
- ret = matroska_resync(matroska, pos);
+ ret = matroska_resync(matroska, matroska->resync_pos);
}
return 0;
timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
- avio_seek(s->pb, st->index_entries[st->nb_index_entries - 1].pos,
- SEEK_SET);
- matroska->current_id = 0;
+ matroska_reset_status(matroska, 0, st->index_entries[st->nb_index_entries - 1].pos);
while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0 || index == st->nb_index_entries - 1) {
matroska_clear_queue(matroska);
if (matroska_parse_cluster(matroska) < 0)
tracks[i].end_timecode = 0;
}
- avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET);
- matroska->current_id = 0;
+ /* We seek to a level 1 element, so set the appropriate status. */
+ matroska_reset_status(matroska, 0, st->index_entries[index].pos);
if (flags & AVSEEK_FLAG_ANY) {
st->skip_to_keyframe = 0;
matroska->skip_to_timecode = timestamp;
}
matroska->skip_to_keyframe = 1;
matroska->done = 0;
- matroska->num_levels = 0;
ff_update_cur_dts(s, st, st->index_entries[index].timestamp);
return 0;
err:
// slightly hackish but allows proper fallback to
// the generic seeking code.
+ matroska_reset_status(matroska, 0, -1);
+ matroska->resync_pos = -1;
matroska_clear_queue(matroska);
- matroska->current_id = 0;
st->skip_to_keyframe =
matroska->skip_to_keyframe = 0;
matroska->done = 0;
- matroska->num_levels = 0;
return -1;
}
for (n = 0; n < matroska->tracks.nb_elem; n++)
if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
av_freep(&tracks[n].audio.buf);
- ebml_free(matroska_cluster, &matroska->current_cluster);
ebml_free(matroska_segment, matroska);
return 0;
static int webm_clusters_start_with_keyframe(AVFormatContext *s)
{
MatroskaDemuxContext *matroska = s->priv_data;
+ uint32_t id = matroska->current_id;
int64_t cluster_pos, before_pos;
int index, rv = 1;
if (s->streams[0]->nb_index_entries <= 0) return 0;
cluster_pos = s->streams[0]->index_entries[index].pos;
before_pos = avio_tell(s->pb);
while (1) {
- int64_t cluster_id = 0, cluster_length = 0;
+ uint64_t cluster_id, cluster_length;
+ int read;
AVPacket *pkt;
avio_seek(s->pb, cluster_pos, SEEK_SET);
// read cluster id and length
- ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id);
- ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
- if (cluster_id != 0xF43B675) { // done with all clusters
+ read = ebml_read_num(matroska, matroska->ctx->pb, 4, &cluster_id, 1);
+ if (read < 0 || cluster_id != 0xF43B675) // done with all clusters
break;
- }
- avio_seek(s->pb, cluster_pos, SEEK_SET);
- matroska->current_id = 0;
+ read = ebml_read_length(matroska, matroska->ctx->pb, &cluster_length);
+ if (read < 0)
+ break;
+
+ matroska_reset_status(matroska, 0, cluster_pos);
matroska_clear_queue(matroska);
if (matroska_parse_cluster(matroska) < 0 ||
!matroska->queue) {
break;
}
pkt = &matroska->queue->pkt;
- cluster_pos += cluster_length + 12; // 12 is the offset of the cluster id and length.
+ // 4 + read is the length of the cluster id and the cluster length field.
+ cluster_pos += 4 + read + cluster_length;
if (!(pkt->flags & AV_PKT_FLAG_KEY)) {
rv = 0;
break;
}
}
- avio_seek(s->pb, before_pos, SEEK_SET);
+
+ /* Restore the status after matroska_read_header: */
+ matroska_reset_status(matroska, id, before_pos);
+
return rv;
}
cues_start = seekhead[i].pos + matroska->segment_start;
if (avio_seek(matroska->ctx->pb, cues_start, SEEK_SET) == cues_start) {
// cues_end is computed as cues_start + cues_length + length of the
- // Cues element ID + EBML length of the Cues element. cues_end is
- // inclusive and the above sum is reduced by 1.
- uint64_t cues_length = 0, cues_id = 0, bytes_read = 0;
- bytes_read += ebml_read_num(matroska, matroska->ctx->pb, 4, &cues_id);
- bytes_read += ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
- cues_end = cues_start + cues_length + bytes_read - 1;
+ // Cues element ID (i.e. 4) + EBML length of the Cues element.
+ // cues_end is inclusive and the above sum is reduced by 1.
+ uint64_t cues_length, cues_id;
+ int bytes_read;
+ bytes_read = ebml_read_num (matroska, matroska->ctx->pb, 4, &cues_id, 1);
+ if (bytes_read < 0 || cues_id != (MATROSKA_ID_CUES & 0xfffffff))
+ return bytes_read < 0 ? bytes_read : AVERROR_INVALIDDATA;
+ bytes_read = ebml_read_length(matroska, matroska->ctx->pb, &cues_length);
+ if (bytes_read < 0)
+ return bytes_read;
+ cues_end = cues_start + 4 + bytes_read + cues_length - 1;
}
avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
if (cues_start == -1 || cues_end == -1) return -1;
projects / ffmpeg / blobdiff