double white_x;
double white_y;
double max_luminance;
- double min_luminance;
+ CountedElement min_luminance;
} MatroskaMasteringMeta;
typedef struct MatroskaTrackVideoColor {
uint64_t default_duration;
uint64_t flag_default;
uint64_t flag_forced;
+ uint64_t flag_comment;
+ uint64_t flag_hearingimpaired;
+ uint64_t flag_visualimpaired;
+ uint64_t flag_textdescriptions;
+ CountedElement flag_original;
uint64_t seek_preroll;
MatroskaTrackVideo video;
MatroskaTrackAudio audio;
typedef struct MatroskaBlock {
uint64_t duration;
- int64_t reference;
+ CountedElement reference;
uint64_t non_simple;
EbmlBin bin;
uint64_t additional_id;
/* byte position of the segment inside the stream */
int64_t segment_start;
+ /* This packet coincides with AVFormatInternal.parse_pkt
+ * and is not owned by us. */
+ AVPacket *pkt;
+
/* the packet queue */
- AVPacketList *queue;
- AVPacketList *queue_end;
+ PacketList *queue;
+ PacketList *queue_end;
int done;
// incomplete type (6.7.2 in C90, 6.9.2 in C99).
// Removing the sizes breaks MSVC.
static EbmlSyntax ebml_syntax[3], matroska_segment[9], matroska_track_video_color[15], matroska_track_video[19],
- matroska_track[27], matroska_track_encoding[6], matroska_track_encodings[2],
+ matroska_track[32], matroska_track_encoding[6], matroska_track_encodings[2],
matroska_track_combine_planes[2], matroska_track_operation[2], matroska_tracks[2],
matroska_attachments[2], matroska_chapter_entry[9], matroska_chapter[6], matroska_chapters[2],
matroska_index_entry[3], matroska_index[2], matroska_tag[3], matroska_tags[2], matroska_seekhead[2],
{ MATROSKA_ID_VIDEOCOLOR_BY, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, b_y) },
{ MATROSKA_ID_VIDEOCOLOR_WHITEX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_x) },
{ MATROSKA_ID_VIDEOCOLOR_WHITEY, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, white_y) },
- { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, min_luminance), { .f=-1 } },
+ { MATROSKA_ID_VIDEOCOLOR_LUMINANCEMIN, EBML_FLOAT, 1, 0, offsetof(MatroskaMasteringMeta, min_luminance) },
{ MATROSKA_ID_VIDEOCOLOR_LUMINANCEMAX, EBML_FLOAT, 0, 0, offsetof(MatroskaMasteringMeta, max_luminance) },
CHILD_OF(matroska_track_video_color)
};
{ MATROSKA_ID_TRACKLANGUAGE, EBML_STR, 0, 0, offsetof(MatroskaTrack, language), { .s = "eng" } },
{ MATROSKA_ID_TRACKDEFAULTDURATION, EBML_UINT, 0, 0, offsetof(MatroskaTrack, default_duration) },
{ MATROSKA_ID_TRACKTIMECODESCALE, EBML_FLOAT, 0, 0, offsetof(MatroskaTrack, time_scale), { .f = 1.0 } },
+ { MATROSKA_ID_TRACKFLAGCOMMENTARY, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_comment), { .u = 0 } },
{ MATROSKA_ID_TRACKFLAGDEFAULT, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_default), { .u = 1 } },
{ MATROSKA_ID_TRACKFLAGFORCED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_forced), { .u = 0 } },
+ { MATROSKA_ID_TRACKFLAGHEARINGIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_hearingimpaired), { .u = 0 } },
+ { MATROSKA_ID_TRACKFLAGVISUALIMPAIRED, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_visualimpaired), { .u = 0 } },
+ { MATROSKA_ID_TRACKFLAGTEXTDESCRIPTIONS, EBML_UINT, 0, 0, offsetof(MatroskaTrack, flag_textdescriptions), { .u = 0 } },
+ { MATROSKA_ID_TRACKFLAGORIGINAL, EBML_UINT, 1, 0, offsetof(MatroskaTrack, flag_original), {.u = 0 } },
{ MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, 0, offsetof(MatroskaTrack, video), { .n = matroska_track_video } },
{ MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, 0, offsetof(MatroskaTrack, audio), { .n = matroska_track_audio } },
{ MATROSKA_ID_TRACKOPERATION, EBML_NEST, 0, 0, offsetof(MatroskaTrack, operation), { .n = matroska_track_operation } },
{ MATROSKA_ID_BLOCKADDITIONS, EBML_NEST, 0, 0, 0, { .n = matroska_blockadditions} },
{ MATROSKA_ID_BLOCKDURATION, EBML_UINT, 0, 0, offsetof(MatroskaBlock, duration) },
{ MATROSKA_ID_DISCARDPADDING, EBML_SINT, 0, 0, offsetof(MatroskaBlock, discard_padding) },
- { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 0, 0, offsetof(MatroskaBlock, reference), { .i = INT64_MIN } },
+ { MATROSKA_ID_BLOCKREFERENCE, EBML_SINT, 1, 0, offsetof(MatroskaBlock, reference) },
{ MATROSKA_ID_CODECSTATE, EBML_NONE },
{ 1, EBML_UINT, 0, 0, offsetof(MatroskaBlock, non_simple), { .u = 1 } },
CHILD_OF(matroska_cluster_parsing)
/*
* Read the next element as an unsigned int.
- * Returns NEEDS_CHECKING.
+ * Returns NEEDS_CHECKING unless size == 0.
*/
-static int ebml_read_uint(AVIOContext *pb, int size, uint64_t *num)
+static int ebml_read_uint(AVIOContext *pb, int size,
+ uint64_t default_value, uint64_t *num)
{
int n = 0;
+ if (size == 0) {
+ *num = default_value;
+ return 0;
+ }
/* big-endian ordering; build up number */
*num = 0;
while (n++ < size)
/*
* Read the next element as a signed int.
- * Returns NEEDS_CHECKING.
+ * Returns NEEDS_CHECKING unless size == 0.
*/
-static int ebml_read_sint(AVIOContext *pb, int size, int64_t *num)
+static int ebml_read_sint(AVIOContext *pb, int size,
+ int64_t default_value, int64_t *num)
{
int n = 1;
if (size == 0) {
- *num = 0;
+ *num = default_value;
+ return 0;
} else {
*num = sign_extend(avio_r8(pb), 8);
/*
* Read the next element as a float.
- * Returns NEEDS_CHECKING or < 0 on obvious failure.
+ * Returns 0 if size == 0, NEEDS_CHECKING or < 0 on obvious failure.
*/
-static int ebml_read_float(AVIOContext *pb, int size, double *num)
+static int ebml_read_float(AVIOContext *pb, int size,
+ double default_value, double *num)
{
- if (size == 0)
- *num = 0;
- else if (size == 4)
+ if (size == 0) {
+ *num = default_value;
+ return 0;
+ } else if (size == 4) {
*num = av_int2float(avio_rb32(pb));
- else if (size == 8)
+ } else if (size == 8) {
*num = av_int2double(avio_rb64(pb));
- else
+ } else
return AVERROR_INVALIDDATA;
return NEEDS_CHECKING;
* Read the next element as an ASCII string.
* 0 is success, < 0 or NEEDS_CHECKING is failure.
*/
-static int ebml_read_ascii(AVIOContext *pb, int size, char **str)
+static int ebml_read_ascii(AVIOContext *pb, int size,
+ const char *default_value, 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 ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
- av_free(res);
- return ret < 0 ? ret : NEEDS_CHECKING;
+ if (size == 0 && default_value) {
+ res = av_strdup(default_value);
+ if (!res)
+ return AVERROR(ENOMEM);
+ } else {
+ /* EBML strings are usually not 0-terminated, so we allocate one
+ * byte more, read the string and NUL-terminate it ourselves. */
+ if (!(res = av_malloc(size + 1)))
+ return AVERROR(ENOMEM);
+ if ((ret = avio_read(pb, (uint8_t *) res, size)) != size) {
+ av_free(res);
+ return ret < 0 ? ret : NEEDS_CHECKING;
+ }
+ (res)[size] = '\0';
}
- (res)[size] = '\0';
av_free(*str);
*str = res;
int res;
if (data) {
- for (int i = 0; syntax[i].id; i++)
+ for (int i = 0; syntax[i].id; i++) {
+ void *dst = (char *)data + syntax[i].data_offset;
switch (syntax[i].type) {
case EBML_UINT:
- *(uint64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.u;
+ *(uint64_t *)dst = syntax[i].def.u;
break;
case EBML_SINT:
- *(int64_t *) ((char *) data + syntax[i].data_offset) = syntax[i].def.i;
+ *(int64_t *) dst = syntax[i].def.i;
break;
case EBML_FLOAT:
- *(double *) ((char *) data + syntax[i].data_offset) = syntax[i].def.f;
+ *(double *) dst = syntax[i].def.f;
break;
case EBML_STR:
case EBML_UTF8:
// the default may be NULL
if (syntax[i].def.s) {
- uint8_t **dst = (uint8_t **) ((uint8_t *) data + syntax[i].data_offset);
- *dst = av_strdup(syntax[i].def.s);
- if (!*dst)
+ *(char**)dst = av_strdup(syntax[i].def.s);
+ if (!*(char**)dst)
return AVERROR(ENOMEM);
}
break;
}
+ }
if (!matroska->levels[matroska->num_levels - 1].length) {
matroska->num_levels--;
switch (syntax->type) {
case EBML_UINT:
- res = ebml_read_uint(pb, length, data);
+ res = ebml_read_uint(pb, length, syntax->def.u, data);
break;
case EBML_SINT:
- res = ebml_read_sint(pb, length, data);
+ res = ebml_read_sint(pb, length, syntax->def.i, data);
break;
case EBML_FLOAT:
- res = ebml_read_float(pb, length, data);
+ res = ebml_read_float(pb, length, syntax->def.f, data);
break;
case EBML_STR:
case EBML_UTF8:
- res = ebml_read_ascii(pb, length, data);
+ res = ebml_read_ascii(pb, length, syntax->def.s, data);
break;
case EBML_BIN:
res = ebml_read_binary(pb, length, pos_alt, data);
mastering_meta->g_x > 0 && mastering_meta->g_y > 0 &&
mastering_meta->b_x > 0 && mastering_meta->b_y > 0 &&
mastering_meta->white_x > 0 && mastering_meta->white_y > 0;
- has_mastering_luminance = mastering_meta->max_luminance > 0;
+ has_mastering_luminance = mastering_meta->max_luminance >
+ mastering_meta->min_luminance.el.f &&
+ mastering_meta->min_luminance.el.f >= 0 &&
+ mastering_meta->min_luminance.count;
if (color->matrix_coefficients != AVCOL_SPC_RESERVED)
st->codecpar->color_space = color->matrix_coefficients;
}
if (has_mastering_luminance) {
metadata->max_luminance = av_d2q(mastering_meta->max_luminance, INT_MAX);
- metadata->min_luminance = av_d2q(mastering_meta->min_luminance, INT_MAX);
+ metadata->min_luminance = av_d2q(mastering_meta->min_luminance.el.f, INT_MAX);
metadata->has_luminance = 1;
}
}
encodings[0].compression.settings.size);
for (j = 0; ff_mkv_codec_tags[j].id != AV_CODEC_ID_NONE; j++) {
- if (!strncmp(ff_mkv_codec_tags[j].str, track->codec_id,
- strlen(ff_mkv_codec_tags[j].str))) {
+ if (av_strstart(track->codec_id, ff_mkv_codec_tags[j].str, NULL)) {
codec_id = ff_mkv_codec_tags[j].id;
break;
}
st->disposition |= AV_DISPOSITION_DEFAULT;
if (track->flag_forced)
st->disposition |= AV_DISPOSITION_FORCED;
+ if (track->flag_comment)
+ st->disposition |= AV_DISPOSITION_COMMENT;
+ if (track->flag_hearingimpaired)
+ st->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
+ if (track->flag_visualimpaired)
+ st->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
+ if (track->flag_original.count > 0)
+ st->disposition |= track->flag_original.el.u ? AV_DISPOSITION_ORIGINAL
+ : AV_DISPOSITION_DUB;
if (!st->codecpar->extradata) {
if (extradata) {
}
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codecpar->codec_type = AVMEDIA_TYPE_SUBTITLE;
+
+ if (track->flag_textdescriptions)
+ st->disposition |= AV_DISPOSITION_DESCRIPTIONS;
}
}
}
ebml_free(ebml_syntax, &ebml);
+ matroska->pkt = s->internal->parse_pkt;
+
/* The next thing is a segment. */
pos = avio_tell(matroska->ctx->pb);
res = ebml_parse(matroska, matroska_segments, matroska);
goto fail;
pos = avio_tell(matroska->ctx->pb);
res = ebml_parse(matroska, matroska_segment, matroska);
+ if (res == AVERROR(EIO)) // EOF is translated to EIO, this exists the loop on EOF
+ goto fail;
}
/* Set data_offset as it might be needed later by seek_frame_generic. */
if (matroska->current_id == MATROSKA_ID_CLUSTER)
st->codecpar->codec_id = AV_CODEC_ID_NONE;
for (i = 0; mkv_image_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
- if (!strncmp(mkv_image_mime_tags[i].str, attachments[j].mime,
- strlen(mkv_image_mime_tags[i].str))) {
+ if (av_strstart(attachments[j].mime, mkv_image_mime_tags[i].str, NULL)) {
st->codecpar->codec_id = mkv_image_mime_tags[i].id;
break;
}
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(pkt);
- pkt->buf = attachments[j].bin.buf;
- attachments[j].bin.buf = NULL;
- pkt->data = attachments[j].bin.data;
- pkt->size = attachments[j].bin.size;
- pkt->stream_index = st->index;
- pkt->flags |= AV_PKT_FLAG_KEY;
+ res = ff_add_attached_pic(s, st, NULL, &attachments[j].bin.buf, 0);
+ if (res < 0)
+ goto fail;
} else {
st->codecpar->codec_type = AVMEDIA_TYPE_ATTACHMENT;
if (ff_alloc_extradata(st->codecpar, attachments[j].bin.size))
attachments[j].bin.size);
for (i = 0; mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
- if (!strncmp(mkv_mime_tags[i].str, attachments[j].mime,
- strlen(mkv_mime_tags[i].str))) {
+ if (av_strstart(attachments[j].mime, mkv_mime_tags[i].str, NULL)) {
st->codecpar->codec_id = mkv_mime_tags[i].id;
break;
}
while (track->audio.pkt_cnt) {
int ret;
- AVPacket pktl, *pkt = &pktl;
+ AVPacket *pkt = matroska->pkt;
ret = av_new_packet(pkt, a);
if (ret < 0) {
uint64_t duration,
int64_t pos)
{
- AVPacket pktl, *pkt = &pktl;
+ AVPacket *pkt = matroska->pkt;
uint8_t *id, *settings, *text, *buf;
int id_len, settings_len, text_len;
uint8_t *p, *q;
{
uint8_t *pkt_data = data;
int res = 0;
- AVPacket pktl, *pkt = &pktl;
+ AVPacket *pkt = matroska->pkt;
if (st->codecpar->codec_id == AV_CODEC_ID_WAVPACK) {
res = matroska_parse_wavpack(track, &pkt_data, &pkt_size);
if (!pkt_size && !additional_size)
goto no_output;
- av_init_packet(pkt);
if (!buf)
pkt->buf = av_buffer_create(pkt_data, pkt_size + AV_INPUT_BUFFER_PADDING_SIZE,
NULL, NULL, 0);
pkt->pos = pos;
pkt->duration = lace_duration;
-#if FF_API_CONVERGENCE_DURATION
-FF_DISABLE_DEPRECATION_WARNINGS
- if (st->codecpar->codec_id == AV_CODEC_ID_SUBRIP) {
- pkt->convergence_duration = lace_duration;
- }
-FF_ENABLE_DEPRECATION_WARNINGS
-#endif
-
res = avpriv_packet_list_put(&matroska->queue, &matroska->queue_end, pkt, NULL, 0);
if (res < 0) {
av_packet_unref(pkt);
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;
+ int is_keyframe = block->non_simple ? block->reference.count == 0 : -1;
uint8_t* additional = block->additional.size > 0 ?
block->additional.data : NULL;
.version = LIBAVUTIL_VERSION_INT,
};
-AVInputFormat ff_matroska_demuxer = {
+const AVInputFormat ff_matroska_demuxer = {
.name = "matroska,webm",
.long_name = NULL_IF_CONFIG_SMALL("Matroska / WebM"),
- .extensions = "mkv,mk3d,mka,mks",
+ .extensions = "mkv,mk3d,mka,mks,webm",
.priv_data_size = sizeof(MatroskaDemuxContext),
.read_probe = matroska_probe,
.read_header = matroska_read_header,
.mime_type = "audio/webm,audio/x-matroska,video/webm,video/x-matroska"
};
-AVInputFormat ff_webm_dash_manifest_demuxer = {
+const AVInputFormat ff_webm_dash_manifest_demuxer = {
.name = "webm_dash_manifest",
.long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),
.priv_data_size = sizeof(MatroskaDemuxContext),