*/
/**
- * @file matroskadec.c
+ * @file libavformat/matroskadec.c
* Matroska file demuxer
* by Ronald Bultje <rbultje@ronald.bitfreak.net>
* with a little help from Moritz Bunkus <moritz@bunkus.org>
#include <stdio.h>
#include "avformat.h"
-/* For codec_get_id(). */
+/* For ff_codec_get_id(). */
#include "riff.h"
#include "isom.h"
#include "matroska.h"
typedef struct {
uint64_t num;
+ uint64_t uid;
uint64_t type;
+ char *name;
char *codec_id;
EbmlBin codec_priv;
char *language;
AVStream *stream;
int64_t end_timecode;
+ int ms_compat;
} MatroskaTrack;
typedef struct {
+ uint64_t uid;
char *filename;
char *mime;
EbmlBin bin;
+
+ AVStream *stream;
} MatroskaAttachement;
typedef struct {
uint64_t end;
uint64_t uid;
char *title;
+
+ AVChapter *chapter;
} MatroskaChapter;
typedef struct {
typedef struct {
char *name;
char *string;
+ char *lang;
+ uint64_t def;
EbmlList sub;
} MatroskaTag;
+typedef struct {
+ char *type;
+ uint64_t typevalue;
+ uint64_t trackuid;
+ uint64_t chapteruid;
+ uint64_t attachuid;
+} MatroskaTagTarget;
+
+typedef struct {
+ MatroskaTagTarget target;
+ EbmlList tag;
+} MatroskaTags;
+
typedef struct {
uint64_t id;
uint64_t pos;
typedef struct {
uint64_t duration;
int64_t reference;
+ uint64_t non_simple;
EbmlBin bin;
} MatroskaBlock;
static EbmlSyntax matroska_track[] = {
{ MATROSKA_ID_TRACKNUMBER, EBML_UINT, 0, offsetof(MatroskaTrack,num) },
+ { MATROSKA_ID_TRACKNAME, EBML_UTF8, 0, offsetof(MatroskaTrack,name) },
+ { MATROSKA_ID_TRACKUID, EBML_UINT, 0, offsetof(MatroskaTrack,uid) },
{ MATROSKA_ID_TRACKTYPE, EBML_UINT, 0, offsetof(MatroskaTrack,type) },
{ MATROSKA_ID_CODECID, EBML_STR, 0, offsetof(MatroskaTrack,codec_id) },
{ MATROSKA_ID_CODECPRIVATE, EBML_BIN, 0, offsetof(MatroskaTrack,codec_priv) },
{ MATROSKA_ID_TRACKVIDEO, EBML_NEST, 0, offsetof(MatroskaTrack,video), {.n=matroska_track_video} },
{ MATROSKA_ID_TRACKAUDIO, EBML_NEST, 0, offsetof(MatroskaTrack,audio), {.n=matroska_track_audio} },
{ MATROSKA_ID_TRACKCONTENTENCODINGS,EBML_NEST, 0, 0, {.n=matroska_track_encodings} },
- { MATROSKA_ID_TRACKUID, EBML_NONE },
- { MATROSKA_ID_TRACKNAME, EBML_NONE },
{ MATROSKA_ID_TRACKFLAGENABLED, EBML_NONE },
{ MATROSKA_ID_TRACKFLAGFORCED, EBML_NONE },
{ MATROSKA_ID_TRACKFLAGLACING, EBML_NONE },
};
static EbmlSyntax matroska_attachment[] = {
+ { MATROSKA_ID_FILEUID, EBML_UINT, 0, offsetof(MatroskaAttachement,uid) },
{ MATROSKA_ID_FILENAME, EBML_UTF8, 0, offsetof(MatroskaAttachement,filename) },
{ MATROSKA_ID_FILEMIMETYPE, EBML_STR, 0, offsetof(MatroskaAttachement,mime) },
{ MATROSKA_ID_FILEDATA, EBML_BIN, 0, offsetof(MatroskaAttachement,bin) },
{ MATROSKA_ID_FILEDESC, EBML_NONE },
- { MATROSKA_ID_FILEUID, EBML_NONE },
{ 0 }
};
static EbmlSyntax matroska_simpletag[] = {
{ MATROSKA_ID_TAGNAME, EBML_UTF8, 0, offsetof(MatroskaTag,name) },
{ MATROSKA_ID_TAGSTRING, EBML_UTF8, 0, offsetof(MatroskaTag,string) },
+ { MATROSKA_ID_TAGLANG, EBML_STR, 0, offsetof(MatroskaTag,lang), {.s="und"} },
+ { MATROSKA_ID_TAGDEFAULT, EBML_UINT, 0, offsetof(MatroskaTag,def) },
{ MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), offsetof(MatroskaTag,sub), {.n=matroska_simpletag} },
- { MATROSKA_ID_TAGLANG, EBML_NONE },
- { MATROSKA_ID_TAGDEFAULT, EBML_NONE },
+ { 0 }
+};
+
+static EbmlSyntax matroska_tagtargets[] = {
+ { MATROSKA_ID_TAGTARGETS_TYPE, EBML_STR, 0, offsetof(MatroskaTagTarget,type) },
+ { MATROSKA_ID_TAGTARGETS_TYPEVALUE, EBML_UINT, 0, offsetof(MatroskaTagTarget,typevalue), {.u=50} },
+ { 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 }
};
static EbmlSyntax matroska_tag[] = {
- { MATROSKA_ID_SIMPLETAG, EBML_NEST, sizeof(MatroskaTag), 0, {.n=matroska_simpletag} },
- { MATROSKA_ID_TAGTARGETS, EBML_NONE },
+ { 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 }
};
static EbmlSyntax matroska_tags[] = {
- { MATROSKA_ID_TAG, EBML_NEST, 0, offsetof(MatroskaDemuxContext,tags), {.n=matroska_tag} },
+ { MATROSKA_ID_TAG, EBML_NEST, sizeof(MatroskaTags), offsetof(MatroskaDemuxContext,tags), {.n=matroska_tag} },
{ 0 }
};
{ MATROSKA_ID_SIMPLEBLOCK, EBML_BIN, 0, offsetof(MatroskaBlock,bin) },
{ MATROSKA_ID_BLOCKDURATION, EBML_UINT, 0, offsetof(MatroskaBlock,duration), {.u=AV_NOPTS_VALUE} },
{ MATROSKA_ID_BLOCKREFERENCE, EBML_UINT, 0, offsetof(MatroskaBlock,reference) },
+ { 1, EBML_UINT, 0, offsetof(MatroskaBlock,non_simple), {.u=1} },
{ 0 }
};
{ 0 }
};
-#define SIZE_OFF(x) sizeof(((AVFormatContext*)0)->x),offsetof(AVFormatContext,x)
-const struct {
- const char name[16];
- int size;
- int offset;
-} metadata[] = {
- { "TITLE", SIZE_OFF(title) },
- { "ARTIST", SIZE_OFF(author) },
- { "WRITTEN_BY", SIZE_OFF(author) },
- { "LEAD_PERFORMER", SIZE_OFF(author) },
- { "COPYRIGHT", SIZE_OFF(copyright) },
- { "COMMENT", SIZE_OFF(comment) },
- { "ALBUM", SIZE_OFF(album) },
- { "DATE_WRITTEN", SIZE_OFF(year) },
- { "DATE_RELEASED", SIZE_OFF(year) },
- { "PART_NUMBER", SIZE_OFF(track) },
- { "GENRE", SIZE_OFF(genre) },
-};
-
/*
* Return: Whether we reached the end of a level in the hierarchy or not.
*/
case MATROSKA_TRACK_ENCODING_COMP_LZO:
do {
olen = pkt_size *= 3;
- pkt_data = av_realloc(pkt_data,
- pkt_size+LZO_OUTPUT_PADDING);
- result = lzo1x_decode(pkt_data, &olen, data, &isize);
- } while (result==LZO_OUTPUT_FULL && pkt_size<10000000);
+ pkt_data = av_realloc(pkt_data, pkt_size+AV_LZO_OUTPUT_PADDING);
+ result = av_lzo1x_decode(pkt_data, &olen, data, &isize);
+ } while (result==AV_LZO_OUTPUT_FULL && pkt_size<10000000);
if (result)
goto failed;
pkt_size -= olen;
av_free(in);
}
-static void matroska_convert_tags(AVFormatContext *s, EbmlList *list)
+static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
+ AVMetadata **metadata, char *prefix)
{
MatroskaTag *tags = list->elem;
- int i, j;
+ char key[1024];
+ int i;
for (i=0; i < list->nb_elem; i++) {
- for (j=0; j < FF_ARRAY_ELEMS(metadata); j++){
- if (!strcmp(tags[i].name, metadata[j].name)) {
- int *ptr = (int *)((char *)s + metadata[j].offset);
- if (*ptr) continue;
- if (metadata[j].size > sizeof(int))
- av_strlcpy((char *)ptr, tags[i].string, metadata[j].size);
- else
- *ptr = atoi(tags[i].string);
- }
- }
+ const char *lang = strcmp(tags[i].lang, "und") ? tags[i].lang : NULL;
+ if (prefix) snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
+ else av_strlcpy(key, tags[i].name, sizeof(key));
+ if (tags[i].def || !lang) {
+ av_metadata_set(metadata, key, tags[i].string);
if (tags[i].sub.nb_elem)
- matroska_convert_tags(s, &tags[i].sub);
+ matroska_convert_tag(s, &tags[i].sub, metadata, key);
+ }
+ if (lang) {
+ av_strlcat(key, "-", sizeof(key));
+ av_strlcat(key, lang, sizeof(key));
+ av_metadata_set(metadata, key, tags[i].string);
+ if (tags[i].sub.nb_elem)
+ matroska_convert_tag(s, &tags[i].sub, metadata, key);
+ }
+ }
+}
+
+static void matroska_convert_tags(AVFormatContext *s)
+{
+ MatroskaDemuxContext *matroska = s->priv_data;
+ MatroskaTags *tags = matroska->tags.elem;
+ int i, j;
+
+ for (i=0; i < matroska->tags.nb_elem; i++) {
+ if (tags[i].target.attachuid) {
+ MatroskaAttachement *attachment = matroska->attachments.elem;
+ for (j=0; j<matroska->attachments.nb_elem; j++)
+ if (attachment[j].uid == tags[i].target.attachuid)
+ matroska_convert_tag(s, &tags[i].tag,
+ &attachment[j].stream->metadata, NULL);
+ } else if (tags[i].target.chapteruid) {
+ MatroskaChapter *chapter = matroska->chapters.elem;
+ for (j=0; j<matroska->chapters.nb_elem; j++)
+ if (chapter[j].uid == tags[i].target.chapteruid)
+ matroska_convert_tag(s, &tags[i].tag,
+ &chapter[j].chapter->metadata, NULL);
+ } else if (tags[i].target.trackuid) {
+ MatroskaTrack *track = matroska->tracks.elem;
+ for (j=0; j<matroska->tracks.nb_elem; j++)
+ if (track[j].uid == tags[i].target.trackuid)
+ matroska_convert_tag(s, &tags[i].tag,
+ &track[j].stream->metadata, NULL);
+ } else {
+ matroska_convert_tag(s, &tags[i].tag, &s->metadata,
+ tags[i].target.type);
+ }
}
}
if (matroska->duration)
matroska->ctx->duration = matroska->duration * matroska->time_scale
* 1000 / AV_TIME_BASE;
- if (matroska->title)
- strncpy(matroska->ctx->title, matroska->title,
- sizeof(matroska->ctx->title)-1);
- matroska_convert_tags(s, &matroska->tags);
+ av_metadata_set(&s->metadata, "title", matroska->title);
tracks = matroska->tracks.elem;
for (i=0; i < matroska->tracks.nb_elem; i++) {
uint8_t *extradata = NULL;
int extradata_size = 0;
int extradata_offset = 0;
+ ByteIOContext b;
/* Apply some sanity checks. */
if (track->type != MATROSKA_TRACK_TYPE_VIDEO &&
if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC")
&& track->codec_priv.size >= 40
&& track->codec_priv.data != NULL) {
+ track->ms_compat = 1;
track->video.fourcc = AV_RL32(track->codec_priv.data + 16);
- codec_id = codec_get_id(codec_bmp_tags, track->video.fourcc);
+ codec_id = ff_codec_get_id(ff_codec_bmp_tags, track->video.fourcc);
+ extradata_offset = 40;
} else if (!strcmp(track->codec_id, "A_MS/ACM")
- && track->codec_priv.size >= 18
+ && track->codec_priv.size >= 14
&& track->codec_priv.data != NULL) {
- uint16_t tag = AV_RL16(track->codec_priv.data);
- codec_id = codec_get_id(codec_wav_tags, tag);
+ init_put_byte(&b, track->codec_priv.data, track->codec_priv.size,
+ URL_RDONLY, NULL, NULL, NULL, NULL);
+ ff_get_wav_header(&b, st->codec, track->codec_priv.size);
+ codec_id = st->codec->codec_id;
+ extradata_offset = FFMIN(track->codec_priv.size, 18);
} else if (!strcmp(track->codec_id, "V_QUICKTIME")
&& (track->codec_priv.size >= 86)
&& (track->codec_priv.data != NULL)) {
track->video.fourcc = AV_RL32(track->codec_priv.data);
- codec_id=codec_get_id(codec_movvideo_tags, track->video.fourcc);
+ codec_id=ff_codec_get_id(codec_movvideo_tags, track->video.fourcc);
} else if (codec_id == CODEC_ID_PCM_S16BE) {
switch (track->audio.bitdepth) {
case 8: codec_id = CODEC_ID_PCM_U8; break;
} else
extradata_size = 2;
} else if (codec_id == CODEC_ID_TTA) {
- ByteIOContext b;
extradata_size = 30;
extradata = av_mallocz(extradata_size);
if (extradata == NULL)
} else if (codec_id == CODEC_ID_RV10 || codec_id == CODEC_ID_RV20 ||
codec_id == CODEC_ID_RV30 || codec_id == CODEC_ID_RV40) {
extradata_offset = 26;
- track->codec_priv.size -= extradata_offset;
} else if (codec_id == CODEC_ID_RA_144) {
track->audio.out_samplerate = 8000;
track->audio.channels = 1;
} else if (codec_id == CODEC_ID_RA_288 || codec_id == CODEC_ID_COOK ||
codec_id == CODEC_ID_ATRAC3) {
- ByteIOContext b;
-
init_put_byte(&b, track->codec_priv.data,track->codec_priv.size,
0, NULL, NULL, NULL, NULL);
url_fskip(&b, 24);
} else {
st->codec->block_align = track->audio.sub_packet_size;
extradata_offset = 78;
- track->codec_priv.size -= extradata_offset;
}
}
+ track->codec_priv.size -= extradata_offset;
if (codec_id == CODEC_ID_NONE)
av_log(matroska->ctx, AV_LOG_INFO,
st->codec->codec_id = codec_id;
st->start_time = 0;
if (strcmp(track->language, "und"))
- av_strlcpy(st->language, track->language, 4);
+ av_metadata_set(&st->metadata, "language", track->language);
+ av_metadata_set(&st->metadata, "title", track->name);
if (track->flag_default)
st->disposition |= AV_DISPOSITION_DEFAULT;
av_reduce(&st->codec->time_base.num, &st->codec->time_base.den,
track->default_duration, 1000000000, 30000);
- if(extradata){
- st->codec->extradata = extradata;
- st->codec->extradata_size = extradata_size;
- } else if(track->codec_priv.data && track->codec_priv.size > 0){
- st->codec->extradata = av_mallocz(track->codec_priv.size +
- FF_INPUT_BUFFER_PADDING_SIZE);
- if(st->codec->extradata == NULL)
- return AVERROR(ENOMEM);
- st->codec->extradata_size = track->codec_priv.size;
- memcpy(st->codec->extradata,
- track->codec_priv.data + extradata_offset,
- track->codec_priv.size);
+ if (!st->codec->extradata) {
+ if(extradata){
+ st->codec->extradata = extradata;
+ st->codec->extradata_size = extradata_size;
+ } else if(track->codec_priv.data && track->codec_priv.size > 0){
+ st->codec->extradata = av_mallocz(track->codec_priv.size +
+ FF_INPUT_BUFFER_PADDING_SIZE);
+ if(st->codec->extradata == NULL)
+ return AVERROR(ENOMEM);
+ st->codec->extradata_size = track->codec_priv.size;
+ memcpy(st->codec->extradata,
+ track->codec_priv.data + extradata_offset,
+ track->codec_priv.size);
+ }
}
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
st->codec->height * track->video.display_width,
st->codec-> width * track->video.display_height,
255);
+ if (st->codec->codec_id != CODEC_ID_H264)
st->need_parsing = AVSTREAM_PARSE_HEADERS;
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
st->codec->codec_type = CODEC_TYPE_AUDIO;
AVStream *st = av_new_stream(s, 0);
if (st == NULL)
break;
- st->filename = av_strdup(attachements[j].filename);
+ av_metadata_set(&st->metadata, "filename",attachements[j].filename);
st->codec->codec_id = CODEC_ID_NONE;
st->codec->codec_type = CODEC_TYPE_ATTACHMENT;
st->codec->extradata = av_malloc(attachements[j].bin.size);
break;
}
}
+ attachements[j].stream = st;
}
}
for (i=0; i<chapters_list->nb_elem; i++)
if (chapters[i].start != AV_NOPTS_VALUE && chapters[i].uid
&& (max_start==0 || chapters[i].start > max_start)) {
+ chapters[i].chapter =
ff_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
chapters[i].start, chapters[i].end,
chapters[i].title);
+ av_metadata_set(&chapters[i].chapter->metadata,
+ "title", chapters[i].title);
max_start = chapters[i].start;
}
}
}
+ matroska_convert_tags(s);
+
return 0;
}
if (res == 0) {
for (n = 0; n < laces; n++) {
- if (st->codec->codec_id == CODEC_ID_RA_288 ||
- st->codec->codec_id == CODEC_ID_COOK ||
- st->codec->codec_id == CODEC_ID_ATRAC3) {
+ if ((st->codec->codec_id == CODEC_ID_RA_288 ||
+ st->codec->codec_id == CODEC_ID_COOK ||
+ st->codec->codec_id == CODEC_ID_ATRAC3) &&
+ st->codec->block_align && track->audio.sub_packet_size) {
int a = st->codec->block_align;
int sps = track->audio.sub_packet_size;
int cfs = track->audio.coded_framesize;
int offset = 0, pkt_size = lace_size[n];
uint8_t *pkt_data = data;
+ if (lace_size[n] > size) {
+ av_log(matroska->ctx, AV_LOG_ERROR, "Invalid packet size\n");
+ break;
+ }
+
if (encodings && encodings->scope & 1) {
offset = matroska_decode_buffer(&pkt_data,&pkt_size, track);
if (offset < 0)
if (av_new_packet(pkt, pkt_size+offset) < 0) {
av_free(pkt);
res = AVERROR(ENOMEM);
- n = laces-1;
break;
}
if (offset)
pkt->flags = is_keyframe;
pkt->stream_index = st->index;
- pkt->pts = timecode;
+ if (track->ms_compat)
+ pkt->dts = timecode;
+ else
+ pkt->pts = timecode;
pkt->pos = pos;
if (st->codec->codec_id == CODEC_ID_TEXT)
pkt->convergence_duration = duration;
if (timecode != AV_NOPTS_VALUE)
timecode = duration ? timecode + duration : AV_NOPTS_VALUE;
data += lace_size[n];
+ size -= lace_size[n];
}
}
blocks_list = &cluster.blocks;
blocks = blocks_list->elem;
for (i=0; i<blocks_list->nb_elem; i++)
- if (blocks[i].bin.size > 0)
+ if (blocks[i].bin.size > 0) {
+ int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
res=matroska_parse_block(matroska,
blocks[i].bin.data, blocks[i].bin.size,
blocks[i].bin.pos, cluster.timecode,
- blocks[i].duration, !blocks[i].reference,
+ blocks[i].duration, is_keyframe,
pos);
+ }
ebml_free(matroska_cluster, &cluster);
if (res < 0) matroska->done = 1;
return res;
while (matroska_deliver_packet(matroska, pkt)) {
if (matroska->done)
- return AVERROR(EIO);
+ return AVERROR_EOF;
matroska_parse_cluster(matroska);
}
matroska_read_packet,
matroska_read_close,
matroska_read_seek,
+ .metadata_conv = ff_mkv_metadata_conv,
};
projects / ffmpeg / blobdiff