---
now withbogus hunks edit corrected
sorry for the mess
libavformat/matroskadec.c | 535 +++++++++++++++++++++++++---------------------
1 file changed, 292 insertions(+), 243 deletions(-)
diff --git a/libavformat/matroskadec.c b/libavformat/matroskadec.c
index bcd7d1a..ac01855 100644
--- a/libavformat/matroskadec.c
+++ b/libavformat/matroskadec.c
@@ -70,8 +70,8 @@ typedef const struct EbmlSyntax {
int list_elem_size;
int data_offset;
union {
- uint64_t u;
- double f;
+ uint64_t u;
+ double f;
const char *s;
const struct EbmlSyntax *n;
} def;
@@ -83,22 +83,22 @@ typedef struct {
} EbmlList;
typedef struct {
- int size;
+ int size;
uint8_t *data;
- int64_t pos;
+ int64_t pos;
} EbmlBin;
typedef struct {
uint64_t version;
uint64_t max_size;
uint64_t id_length;
- char *doctype;
+ char *doctype;
uint64_t doctype_version;
} Ebml;
typedef struct {
uint64_t algo;
- EbmlBin settings;
+ EbmlBin settings;
} MatroskaTrackCompression;
typedef struct {
@@ -108,7 +108,7 @@ typedef struct {
} MatroskaTrackEncoding;
typedef struct {
- double frame_rate;
+ double frame_rate;
uint64_t display_width;
uint64_t display_height;
uint64_t pixel_width;
@@ -117,18 +117,18 @@ typedef struct {
} MatroskaTrackVideo;
typedef struct {
- double samplerate;
- double out_samplerate;
+ double samplerate;
+ double out_samplerate;
uint64_t bitdepth;
uint64_t channels;
/* real audio header (extracted from extradata) */
- int coded_framesize;
- int sub_packet_h;
- int frame_size;
- int sub_packet_size;
- int sub_packet_cnt;
- int pkt_cnt;
+ int coded_framesize;
+ int sub_packet_h;
+ int frame_size;
+ int sub_packet_size;
+ int sub_packet_cnt;
+ int pkt_cnt;
uint64_t buf_timecode;
uint8_t *buf;
} MatroskaTrackAudio;
@@ -137,10 +137,10 @@ typedef struct {
uint64_t num;
uint64_t uid;
uint64_t type;
- char *name;
- char *codec_id;
- EbmlBin codec_priv;
- char *language;
+ char *name;
+ char *codec_id;
+ EbmlBin codec_priv;
+ char *language;
double time_scale;
uint64_t default_duration;
uint64_t flag_default;
@@ -167,7 +167,7 @@ typedef struct {
uint64_t start;
uint64_t end;
uint64_t uid;
- char *title;
+ char *title;
AVChapter *chapter;
} MatroskaChapter;
@@ -191,7 +191,7 @@ typedef struct {
} MatroskaTag;
typedef struct {
- char *type;
+ char *type;
uint64_t typevalue;
uint64_t trackuid;
uint64_t chapteruid;
@@ -228,8 +228,8 @@ typedef struct {
uint32_t current_id;
uint64_t time_scale;
- double duration;
- char *title;
+ double duration;
+ char *title;
EbmlList tracks;
EbmlList attachments;
EbmlList chapters;
@@ -264,9 +264,9 @@ typedef struct {
typedef struct {
uint64_t duration;
- int64_t reference;
+ int64_t reference;
uint64_t non_simple;
- EbmlBin bin;
+ EbmlBin bin;
} MatroskaBlock;
static EbmlSyntax ebml_header[] = {
@@ -576,8 +576,8 @@ static int matroska_resync(MatroskaDemuxContext *matroska,
int64_t last_pos)
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;
- return 0;
+ matroska->current_id = id;
+ return 0;
}
id = (id << 8) | avio_r8(pb);
}
@@ -592,7 +592,7 @@ eof:
static int ebml_level_end(MatroskaDemuxContext *matroska)
{
AVIOContext *pb = matroska->ctx->pb;
- int64_t pos = avio_tell(pb);
+ int64_t pos = avio_tell(pb);
if (matroska->num_levels > 0) {
MatroskaLevel *level = &matroska->levels[matroska->num_levels - 1];
@@ -615,7 +615,7 @@ static int ebml_level_end(MatroskaDemuxContext *matroska)
static int ebml_read_num(MatroskaDemuxContext *matroska, AVIOContext *pb,
int max_size, uint64_t *number)
{
- int read = 1, n = 1;
+ int read = 1, n = 1;
uint64_t total = 0;
/* The first byte tells us the length in bytes - avio_r8() can normally
@@ -626,7 +626,7 @@ static int ebml_read_num(MatroskaDemuxContext *matroska,
AVIOContext *pb,
if (!pb->eof_reached) {
int64_t pos = avio_tell(pb);
av_log(matroska->ctx, AV_LOG_ERROR,
- "Read error at pos. %"PRIu64" (0x%"PRIx64")\n",
+ "Read error at pos. %" PRIu64 " (0x%" PRIx64 ")\n",
pos, pos);
return pb->error ? pb->error : AVERROR(EIO);
}
@@ -696,7 +696,7 @@ static int ebml_read_float(AVIOContext *pb, int size,
double *num)
*num = 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
return AVERROR_INVALIDDATA;
@@ -716,7 +716,7 @@ static int ebml_read_ascii(AVIOContext *pb, int size, char
**str)
* 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 (avio_read(pb, (uint8_t *)res, size) != size) {
av_free(res);
return AVERROR(EIO);
}
@@ -798,7 +798,7 @@ static int matroska_ebmlnum_sint(MatroskaDemuxContext
*matroska,
return res;
/* make signed (weird way) */
- *num = unum - ((1LL << (7*res - 1)) - 1);
+ *num = unum - ((1LL << (7 * res - 1)) - 1);
return res;
}
@@ -810,12 +810,12 @@ static int ebml_parse_id(MatroskaDemuxContext *matroska,
EbmlSyntax *syntax,
uint32_t id, void *data)
{
int i;
- for (i=0; syntax[i].id; i++)
+ 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 == 0xffffffffffffff)
+ matroska->levels[matroska->num_levels - 1].length == 0xffffffffffffff)
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_INFO, "Unknown entry 0x%X\n", id);
@@ -833,7 +833,7 @@ static int ebml_parse(MatroskaDemuxContext *matroska,
EbmlSyntax *syntax,
int res = ebml_read_num(matroska, matroska->ctx->pb, 4, &id);
if (res < 0)
return res;
- matroska->current_id = id | 1 << 7*res;
+ matroska->current_id = id | 1 << 7 * res;
}
return ebml_parse_id(matroska, syntax, matroska->current_id, data);
}
@@ -843,13 +843,13 @@ static int ebml_parse_nest(MatroskaDemuxContext
*matroska, EbmlSyntax *syntax,
{
int i, res = 0;
- for (i=0; syntax[i].id; i++)
+ for (i = 0; syntax[i].id; i++)
switch (syntax[i].type) {
case EBML_UINT:
*(uint64_t *)((char *)data+syntax[i].data_offset) =
syntax[i].def.u;
break;
case EBML_FLOAT:
- *(double *)((char *)data+syntax[i].data_offset) =
syntax[i].def.f;
+ *(double *)((char *)data + syntax[i].data_offset) =
syntax[i].def.f;
break;
case EBML_STR:
case EBML_UTF8:
@@ -896,7 +896,7 @@ static int ebml_parse_elem(MatroskaDemuxContext *matroska,
list->nb_elem = 0;
return res;
}
- data = (char*)list->elem + list->nb_elem*syntax->list_elem_size;
+ data = (char *)list->elem + list->nb_elem * syntax->list_elem_size;
memset(data, 0, syntax->list_elem_size);
list->nb_elem++;
}
@@ -907,26 +907,32 @@ static int ebml_parse_elem(MatroskaDemuxContext *matroska,
return res;
if (max_lengths[syntax->type] && length > max_lengths[syntax->type]) {
av_log(matroska->ctx, AV_LOG_ERROR,
- "Invalid length 0x%"PRIx64" > 0x%"PRIx64" for syntax
element %i\n",
+ "Invalid length 0x%" PRIx64 " > 0x%" PRIx64
+ " for syntax element %i\n",
length, max_lengths[syntax->type], syntax->type);
return AVERROR_INVALIDDATA;
}
}
switch (syntax->type) {
- case EBML_UINT: res = ebml_read_uint (pb, length, data); break;
- case EBML_FLOAT: res = ebml_read_float (pb, length, data); break;
+ case EBML_UINT: res = ebml_read_uint(pb, length, data);
+ break;
+ case EBML_FLOAT: res = ebml_read_float(pb, length, data);
+ break;
case EBML_STR:
- case EBML_UTF8: res = ebml_read_ascii (pb, length, data); break;
- case EBML_BIN: res = ebml_read_binary(pb, length, data); break;
- case EBML_NEST: if ((res=ebml_read_master(matroska, length)) < 0)
- return res;
- if (id == MATROSKA_ID_SEGMENT)
- matroska->segment_start =
avio_tell(matroska->ctx->pb);
- return ebml_parse_nest(matroska, syntax->def.n, data);
+ case EBML_UTF8: res = ebml_read_ascii(pb, length, data);
+ break;
+ case EBML_BIN: res = ebml_read_binary(pb, length, data);
+ break;
+ case EBML_NEST:
+ if ((res = ebml_read_master(matroska, length)) < 0)
+ return res;
+ if (id == MATROSKA_ID_SEGMENT)
+ matroska->segment_start = avio_tell(matroska->ctx->pb);
+ return ebml_parse_nest(matroska, syntax->def.n, data);
case EBML_PASS: return ebml_parse_id(matroska, syntax->def.n, id, data);
case EBML_STOP: return 1;
- default: return avio_skip(pb,length)<0 ? AVERROR(EIO) : 0;
+ default: return avio_skip(pb, length) < 0 ? AVERROR(EIO) : 0;
}
if (res == AVERROR_INVALIDDATA)
av_log(matroska->ctx, AV_LOG_ERROR, "Invalid element\n");
@@ -938,17 +944,20 @@ static int ebml_parse_elem(MatroskaDemuxContext *matroska,
static void ebml_free(EbmlSyntax *syntax, void *data)
{
int i, j;
- for (i=0; syntax[i].id; i++) {
+ for (i = 0; syntax[i].id; i++) {
void *data_off = (char *)data + syntax[i].data_offset;
switch (syntax[i].type) {
case EBML_STR:
- case EBML_UTF8: av_freep(data_off); break;
- case EBML_BIN: av_freep(&((EbmlBin *)data_off)->data); break;
+ case EBML_UTF8: av_freep(data_off);
+ break;
+ case EBML_BIN: av_freep(&((EbmlBin *)data_off)->data);
+ break;
case EBML_NEST:
if (syntax[i].list_elem_size) {
EbmlList *list = data_off;
char *ptr = list->elem;
- for (j=0; j<list->nb_elem; j++, ptr+=syntax[i].list_elem_size)
+ for (j = 0; j < list->nb_elem;
+ j++, ptr += syntax[i].list_elem_size)
ebml_free(syntax[i].def.n, ptr);
av_free(list->elem);
} else
@@ -958,14 +967,13 @@ static void ebml_free(EbmlSyntax *syntax, void *data)
}
}
-
/*
* Autodetecting...
*/
static int matroska_probe(AVProbeData *p)
{
uint64_t total = 0;
- int len_mask = 0x80, size = 1, n = 1, i;
+ int len_mask = 0x80, size = 1, n = 1, i;
/* EBML header? */
if (AV_RB32(p->buf) != EBML_ID_HEADER)
@@ -978,14 +986,14 @@ static int matroska_probe(AVProbeData *p)
len_mask >>= 1;
}
if (size > 8)
- return 0;
+ return 0;
total &= (len_mask - 1);
while (n < size)
total = (total << 8) | p->buf[4 + n++];
/* Does the probe data contain the whole header? */
if (p->buf_size < 4 + size + total)
- return 0;
+ return 0;
/* The header should contain a known document type. For now,
* we don't parse the whole header but simply check for the
@@ -995,8 +1003,8 @@ static int matroska_probe(AVProbeData *p)
int probelen = strlen(matroska_doctypes[i]);
if (total < probelen)
continue;
- for (n = 4+size; n <= 4+size+total-probelen; n++)
- if (!memcmp(p->buf+n, matroska_doctypes[i], probelen))
+ for (n = 4 + size; n <= 4 + size + total - probelen; n++)
+ if (!memcmp(p->buf + n, matroska_doctypes[i], probelen))
return AVPROBE_SCORE_MAX;
}
@@ -1010,7 +1018,7 @@ static MatroskaTrack
*matroska_find_track_by_num(MatroskaDemuxContext *matroska,
MatroskaTrack *tracks = matroska->tracks.elem;
int i;
- for (i=0; i < matroska->tracks.nb_elem; i++)
+ for (i = 0; i < matroska->tracks.nb_elem; i++)
if (tracks[i].num == num)
return &tracks[i];
@@ -1018,13 +1026,13 @@ static MatroskaTrack
*matroska_find_track_by_num(MatroskaDemuxContext *matroska,
return NULL;
}
-static int matroska_decode_buffer(uint8_t** buf, int* buf_size,
+static int matroska_decode_buffer(uint8_t **buf, int *buf_size,
MatroskaTrack *track)
{
MatroskaTrackEncoding *encodings = track->encodings.elem;
- uint8_t* data = *buf;
+ uint8_t *data = *buf;
int isize = *buf_size;
- uint8_t* pkt_data = NULL;
+ uint8_t *pkt_data = NULL;
uint8_t av_unused *newpktdata;
int pkt_size = isize;
int result = 0;
@@ -1061,7 +1069,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
}
pkt_data = newpktdata;
result = av_lzo1x_decode(pkt_data, &olen, data, &isize);
- } while (result==AV_LZO_OUTPUT_FULL && pkt_size<10000000);
+ } while (result == AV_LZO_OUTPUT_FULL && pkt_size < 10000000);
if (result) {
result = AVERROR_INVALIDDATA;
goto failed;
@@ -1071,7 +1079,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
#endif
#if CONFIG_ZLIB
case MATROSKA_TRACK_ENCODING_COMP_ZLIB: {
- z_stream zstream = {0};
+ z_stream zstream = { 0 };
if (inflateInit(&zstream) != Z_OK)
return -1;
zstream.next_in = data;
@@ -1087,7 +1095,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
zstream.avail_out = pkt_size - zstream.total_out;
zstream.next_out = pkt_data + zstream.total_out;
result = inflate(&zstream, Z_NO_FLUSH);
- } while (result==Z_OK && pkt_size<10000000);
+ } while (result == Z_OK && pkt_size < 10000000);
pkt_size = zstream.total_out;
inflateEnd(&zstream);
if (result != Z_STREAM_END) {
@@ -1102,7 +1110,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
#endif
#if CONFIG_BZLIB
case MATROSKA_TRACK_ENCODING_COMP_BZLIB: {
- bz_stream bzstream = {0};
+ bz_stream bzstream = { 0 };
if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
return -1;
bzstream.next_in = data;
@@ -1118,7 +1126,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
bzstream.next_out = pkt_data + bzstream.total_out_lo32;
result = BZ2_bzDecompress(&bzstream);
- } while (result==BZ_OK && pkt_size<10000000);
+ } while (result == BZ_OK && pkt_size < 10000000);
pkt_size = bzstream.total_out_lo32;
BZ2_bzDecompressEnd(&bzstream);
if (result != BZ_STREAM_END) {
@@ -1138,7 +1146,7 @@ static int matroska_decode_buffer(uint8_t** buf, int*
buf_size,
*buf = pkt_data;
*buf_size = pkt_size;
return 0;
- failed:
+failed:
av_free(pkt_data);
return result;
}
@@ -1147,27 +1155,34 @@ static void
matroska_fix_ass_packet(MatroskaDemuxContext *matroska,
AVPacket *pkt, uint64_t display_duration)
{
AVBufferRef *line;
- char *layer, *ptr = pkt->data, *end = ptr+pkt->size;
- for (; *ptr!=',' && ptr<end-1; ptr++);
+ char *layer, *ptr = pkt->data, *end = ptr + pkt->size;
+ for (; *ptr != ',' && ptr < end - 1; ptr++) ;
if (*ptr == ',')
layer = ++ptr;
- for (; *ptr!=',' && ptr<end-1; ptr++);
+ for (; *ptr != ',' && ptr < end - 1; ptr++) ;
if (*ptr == ',') {
int64_t end_pts = pkt->pts + display_duration;
int sc = matroska->time_scale * pkt->pts / 10000000;
int ec = matroska->time_scale * end_pts / 10000000;
int sh, sm, ss, eh, em, es, len;
- sh = sc/360000; sc -= 360000*sh;
- sm = sc/ 6000; sc -= 6000*sm;
- ss = sc/ 100; sc -= 100*ss;
- eh = ec/360000; ec -= 360000*eh;
- em = ec/ 6000; ec -= 6000*em;
- es = ec/ 100; ec -= 100*es;
+ sh = sc / 360000;
+ sc -= 360000 * sh;
+ sm = sc / 6000;
+ sc -= 6000 * sm;
+ ss = sc / 100;
+ sc -= 100 * ss;
+ eh = ec / 360000;
+ ec -= 360000 * eh;
+ em = ec / 6000;
+ ec -= 6000 * em;
+ es = ec / 100;
+ ec -= 100 * es;
*ptr++ = '\0';
- len = 50 + end-ptr + FF_INPUT_BUFFER_PADDING_SIZE;
+ len = 50 + end - ptr + FF_INPUT_BUFFER_PADDING_SIZE;
if (!(line = av_buffer_alloc(len)))
return;
- snprintf(line->data, len,"Dialogue:
%s,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s\r\n",
+ snprintf(line->data, len,
+ "Dialogue: %s,%d:%02d:%02d.%02d,%d:%02d:%02d.%02d,%s\r\n",
layer, sh, sm, ss, sc, eh, em, es, ec, ptr);
av_buffer_unref(&pkt->buf);
pkt->buf = line;
@@ -1197,20 +1212,23 @@ static void matroska_convert_tag(AVFormatContext *s,
EbmlList *list,
char key[1024];
int i;
- for (i=0; i < list->nb_elem; i++) {
- const char *lang = tags[i].lang && strcmp(tags[i].lang, "und") ?
- tags[i].lang : NULL;
+ for (i = 0; i < list->nb_elem; i++) {
+ const char *lang = tags[i].lang && strcmp(tags[i].lang, "und")
+ ? tags[i].lang
+ : NULL;
if (!tags[i].name) {
av_log(s, AV_LOG_WARNING, "Skipping invalid tag with no
TagName.\n");
continue;
}
- if (prefix) snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
- else av_strlcpy(key, tags[i].name, sizeof(key));
+ 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_dict_set(metadata, key, tags[i].string, 0);
- if (tags[i].sub.nb_elem)
- matroska_convert_tag(s, &tags[i].sub, metadata, key);
+ av_dict_set(metadata, key, tags[i].string, 0);
+ if (tags[i].sub.nb_elem)
+ matroska_convert_tag(s, &tags[i].sub, metadata, key);
}
if (lang) {
av_strlcat(key, "-", sizeof(key));
@@ -1229,24 +1247,24 @@ static void matroska_convert_tags(AVFormatContext *s)
MatroskaTags *tags = matroska->tags.elem;
int i, j;
- for (i=0; i < matroska->tags.nb_elem; i++) {
+ 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
- && attachment[j].stream)
+ for (j = 0; j < matroska->attachments.nb_elem; j++)
+ if (attachment[j].uid == tags[i].target.attachuid &&
+ attachment[j].stream)
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
- && chapter[j].chapter)
+ for (j = 0; j < matroska->chapters.nb_elem; j++)
+ if (chapter[j].uid == tags[i].target.chapteruid &&
+ chapter[j].chapter)
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++)
+ for (j = 0; j < matroska->tracks.nb_elem; j++)
if (track[j].uid == tags[i].target.trackuid && track[j].stream)
matroska_convert_tag(s, &tags[i].tag,
&track[j].stream->metadata, NULL);
@@ -1257,20 +1275,21 @@ static void matroska_convert_tags(AVFormatContext *s)
}
}
-static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int
idx)
+static int matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska,
+ int idx)
{
- EbmlList *seekhead_list = &matroska->seekhead;
+ EbmlList *seekhead_list = &matroska->seekhead;
MatroskaSeekhead *seekhead = seekhead_list->elem;
- uint32_t level_up = matroska->level_up;
- int64_t before_pos = avio_tell(matroska->ctx->pb);
- uint32_t saved_id = matroska->current_id;
+ uint32_t level_up = matroska->level_up;
+ int64_t before_pos = avio_tell(matroska->ctx->pb);
+ uint32_t saved_id = matroska->current_id;
MatroskaLevel level;
int64_t offset;
int ret = 0;
- if (idx >= seekhead_list->nb_elem
- || seekhead[idx].id == MATROSKA_ID_SEEKHEAD
- || seekhead[idx].id == MATROSKA_ID_CLUSTER)
+ if (idx >= seekhead_list->nb_elem ||
+ seekhead[idx].id == MATROSKA_ID_SEEKHEAD ||
+ seekhead[idx].id == MATROSKA_ID_CLUSTER)
return 0;
/* seek */
@@ -1302,7 +1321,7 @@ static int
matroska_parse_seekhead_entry(MatroskaDemuxContext *matroska, int idx
}
/* seek back */
avio_seek(matroska->ctx->pb, before_pos, SEEK_SET);
- matroska->level_up = level_up;
+ matroska->level_up = level_up;
matroska->current_id = saved_id;
return ret;
@@ -1335,8 +1354,9 @@ static void
matroska_execute_seekhead(MatroskaDemuxContext *matroska)
}
}
-static void matroska_parse_cues(MatroskaDemuxContext *matroska) {
- EbmlList *seekhead_list = &matroska->seekhead;
+static void matroska_parse_cues(MatroskaDemuxContext *matroska)
+{
+ EbmlList *seekhead_list = &matroska->seekhead;
MatroskaSeekhead *seekhead = seekhead_list->elem;
EbmlList *index_list;
MatroskaIndex *index;
@@ -1352,8 +1372,8 @@ static void matroska_parse_cues(MatroskaDemuxContext
*matroska) {
index_list = &matroska->index;
index = index_list->elem;
- if (index_list->nb_elem
- && index[0].time > 1E14/matroska->time_scale) {
+ if (index_list->nb_elem &&
+ index[0].time > 1E14 / matroska->time_scale) {
av_log(matroska->ctx, AV_LOG_WARNING, "Working around broken
index.\n");
index_scale = matroska->time_scale;
}
@@ -1365,7 +1385,7 @@ static void matroska_parse_cues(MatroskaDemuxContext
*matroska) {
if (track && track->stream)
av_add_index_entry(track->stream,
pos[j].pos + matroska->segment_start,
- index[i].time/index_scale, 0, 0,
+ index[i].time / index_scale, 0, 0,
AVINDEX_KEYFRAME);
}
}
@@ -1373,10 +1393,10 @@ static void matroska_parse_cues(MatroskaDemuxContext
*matroska) {
static int matroska_aac_profile(char *codec_id)
{
- static const char * const aac_profiles[] = { "MAIN", "LC", "SSR" };
+ static const char *const aac_profiles[] = { "MAIN", "LC", "SSR" };
int profile;
- for (profile=0; profile<FF_ARRAY_ELEMS(aac_profiles); profile++)
+ for (profile = 0; profile < FF_ARRAY_ELEMS(aac_profiles); profile++)
if (strstr(codec_id, aac_profiles[profile]))
break;
return profile + 1;
@@ -1386,7 +1406,7 @@ static int matroska_aac_sri(int samplerate)
{
int sri;
- for (sri=0; sri<FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
+ for (sri = 0; sri < FF_ARRAY_ELEMS(avpriv_mpeg4audio_sample_rates); sri++)
if (avpriv_mpeg4audio_sample_rates[sri] == samplerate)
break;
return sri;
@@ -1409,13 +1429,16 @@ static int matroska_read_header(AVFormatContext *s)
matroska->ctx = s;
/* First read the EBML header. */
- if (ebml_parse(matroska, ebml_syntax, &ebml)
- || ebml.version > EBML_VERSION || ebml.max_size >
sizeof(uint64_t)
- || ebml.id_length > sizeof(uint32_t) || ebml.doctype_version > 2) {
+ if (ebml_parse(matroska, ebml_syntax, &ebml) ||
+ ebml.version > EBML_VERSION ||
+ ebml.max_size > sizeof(uint64_t) ||
+ ebml.id_length > sizeof(uint32_t) || ebml.doctype_version > 2) {
av_log(matroska->ctx, AV_LOG_ERROR,
"EBML header using unsupported features\n"
- "(EBML version %"PRIu64", doctype %s, doc version %"PRIu64")\n",
+ "(EBML version %"PRIu64
+ ", doctype %s, doc version %"PRIu64")\n",
ebml.version, ebml.doctype, ebml.doctype_version);
+
ebml_free(ebml_syntax, &ebml);
return AVERROR_PATCHWELCOME;
}
@@ -1452,7 +1475,7 @@ static int matroska_read_header(AVFormatContext *s)
av_dict_set(&s->metadata, "title", matroska->title, 0);
tracks = matroska->tracks.elem;
- for (i=0; i < matroska->tracks.nb_elem; i++) {
+ for (i = 0; i < matroska->tracks.nb_elem; i++) {
MatroskaTrack *track = &tracks[i];
enum AVCodecID codec_id = AV_CODEC_ID_NONE;
EbmlList *encodings_list = &track->encodings;
@@ -1467,7 +1490,7 @@ static int matroska_read_header(AVFormatContext *s)
track->type != MATROSKA_TRACK_TYPE_AUDIO &&
track->type != MATROSKA_TRACK_TYPE_SUBTITLE) {
av_log(matroska->ctx, AV_LOG_INFO,
- "Unknown or unsupported track type %"PRIu64"\n",
+ "Unknown or unsupported track type %" PRIu64 "\n",
track->type);
continue;
}
@@ -1476,7 +1499,7 @@ static int matroska_read_header(AVFormatContext *s)
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
if (!track->default_duration && track->video.frame_rate > 0)
- track->default_duration = 1000000000/track->video.frame_rate;
+ track->default_duration = 1000000000 / track->video.frame_rate;
if (!track->video.display_width)
track->video.display_width = track->video.pixel_width;
if (!track->video.display_height)
@@ -1504,7 +1527,7 @@ static int matroska_read_header(AVFormatContext *s)
encodings[0].scope = 0;
av_log(matroska->ctx, AV_LOG_ERROR,
"Unsupported encoding type");
- } else if (track->codec_priv.size && encodings[0].scope&2) {
+ } else if (track->codec_priv.size && encodings[0].scope & 2) {
uint8_t *codec_priv = track->codec_priv.data;
int ret = matroska_decode_buffer(&track->codec_priv.data,
&track->codec_priv.size,
@@ -1521,10 +1544,10 @@ static int matroska_read_header(AVFormatContext *s)
}
}
- 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))){
- codec_id= ff_mkv_codec_tags[j].id;
+ 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))) {
+ codec_id = ff_mkv_codec_tags[j].id;
break;
}
}
@@ -1533,42 +1556,52 @@ static int matroska_read_header(AVFormatContext *s)
if (st == NULL)
return AVERROR(ENOMEM);
- if (!strcmp(track->codec_id, "V_MS/VFW/FOURCC")
- && track->codec_priv.size >= 40
- && track->codec_priv.data != NULL) {
+ 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 = 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 >= 14
- && track->codec_priv.data != NULL) {
+ } else if (!strcmp(track->codec_id, "A_MS/ACM") &&
+ track->codec_priv.size >= 14 &&
+ track->codec_priv.data != NULL) {
int ret;
- ffio_init_context(&b, track->codec_priv.data,
track->codec_priv.size,
- 0, NULL, NULL, NULL, NULL);
+ ffio_init_context(&b, track->codec_priv.data,
+ track->codec_priv.size,
+ 0, NULL, NULL, NULL,
+ NULL);
ret = ff_get_wav_header(&b, st->codec, track->codec_priv.size);
if (ret < 0)
return ret;
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)) {
+ } 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=ff_codec_get_id(ff_codec_movvideo_tags,
track->video.fourcc);
+ codec_id = ff_codec_get_id(ff_codec_movvideo_tags,
+ track->video.fourcc);
} else if (codec_id == AV_CODEC_ID_PCM_S16BE) {
switch (track->audio.bitdepth) {
- case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
- case 24: codec_id = AV_CODEC_ID_PCM_S24BE; break;
- case 32: codec_id = AV_CODEC_ID_PCM_S32BE; break;
+ case 8: codec_id = AV_CODEC_ID_PCM_U8;
+ break;
+ case 24: codec_id = AV_CODEC_ID_PCM_S24BE;
+ break;
+ case 32: codec_id = AV_CODEC_ID_PCM_S32BE;
+ break;
}
} else if (codec_id == AV_CODEC_ID_PCM_S16LE) {
switch (track->audio.bitdepth) {
- case 8: codec_id = AV_CODEC_ID_PCM_U8; break;
- case 24: codec_id = AV_CODEC_ID_PCM_S24LE; break;
- case 32: codec_id = AV_CODEC_ID_PCM_S32LE; break;
+ case 8: codec_id = AV_CODEC_ID_PCM_U8;
+ break;
+ case 24: codec_id = AV_CODEC_ID_PCM_S24LE;
+ break;
+ case 32: codec_id = AV_CODEC_ID_PCM_S32LE;
+ break;
}
- } else if (codec_id==AV_CODEC_ID_PCM_F32LE &&
track->audio.bitdepth==64) {
+ } else if (codec_id == AV_CODEC_ID_PCM_F32LE &&
+ track->audio.bitdepth == 64) {
codec_id = AV_CODEC_ID_PCM_F64LE;
} else if (codec_id == AV_CODEC_ID_AAC && !track->codec_priv.size) {
int profile = matroska_aac_profile(track->codec_id);
@@ -1576,20 +1609,20 @@ static int matroska_read_header(AVFormatContext *s)
extradata = av_mallocz(5 + FF_INPUT_BUFFER_PADDING_SIZE);
if (extradata == NULL)
return AVERROR(ENOMEM);
- extradata[0] = (profile << 3) | ((sri&0x0E) >> 1);
- extradata[1] = ((sri&0x01) << 7) | (track->audio.channels<<3);
+ extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
+ extradata[1] = ((sri & 0x01) << 7) | (track->audio.channels << 3);
if (strstr(track->codec_id, "SBR")) {
- sri = matroska_aac_sri(track->audio.out_samplerate);
- extradata[2] = 0x56;
- extradata[3] = 0xE5;
- extradata[4] = 0x80 | (sri<<3);
+ sri = matroska_aac_sri(track->audio.out_samplerate);
+ extradata[2] = 0x56;
+ extradata[3] = 0xE5;
+ extradata[4] = 0x80 | (sri << 3);
extradata_size = 5;
} else
extradata_size = 2;
} else if (codec_id == AV_CODEC_ID_ALAC && track->codec_priv.size) {
/* Only ALAC's magic cookie is stored in Matroska's track headers.
- Create the "atom size", "tag", and "tag version" fields the
- decoder expects manually. */
+ * Create the "atom size", "tag", and "tag version" fields the
+ * decoder expects manually. */
extradata_size = 12 + track->codec_priv.size;
extradata = av_mallocz(extradata_size +
FF_INPUT_BUFFER_PADDING_SIZE);
if (extradata == NULL)
@@ -1598,31 +1631,36 @@ static int matroska_read_header(AVFormatContext *s)
memcpy(&extradata[4], "alac", 4);
AV_WB32(&extradata[8], 0);
memcpy(&extradata[12], track->codec_priv.data,
- track->codec_priv.size);
+ track->codec_priv.size);
} else if (codec_id == AV_CODEC_ID_TTA) {
extradata_size = 30;
extradata = av_mallocz(extradata_size);
if (extradata == NULL)
return AVERROR(ENOMEM);
ffio_init_context(&b, extradata, extradata_size, 1,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL);
avio_write(&b, "TTA1", 4);
avio_wl16(&b, 1);
avio_wl16(&b, track->audio.channels);
avio_wl16(&b, track->audio.bitdepth);
avio_wl32(&b, track->audio.out_samplerate);
avio_wl32(&b, matroska->ctx->duration *
track->audio.out_samplerate);
- } else if (codec_id == AV_CODEC_ID_RV10 || codec_id ==
AV_CODEC_ID_RV20 ||
- codec_id == AV_CODEC_ID_RV30 || codec_id ==
AV_CODEC_ID_RV40) {
+ } else if (codec_id == AV_CODEC_ID_RV10 ||
+ codec_id == AV_CODEC_ID_RV20 ||
+ codec_id == AV_CODEC_ID_RV30 ||
+ codec_id == AV_CODEC_ID_RV40) {
extradata_offset = 26;
} else if (codec_id == AV_CODEC_ID_RA_144) {
track->audio.out_samplerate = 8000;
- track->audio.channels = 1;
- } else if (codec_id == AV_CODEC_ID_RA_288 || codec_id ==
AV_CODEC_ID_COOK ||
- codec_id == AV_CODEC_ID_ATRAC3 || codec_id ==
AV_CODEC_ID_SIPR) {
+ track->audio.channels = 1;
+ } else if (codec_id == AV_CODEC_ID_RA_288 ||
+ codec_id == AV_CODEC_ID_COOK ||
+ codec_id == AV_CODEC_ID_ATRAC3 ||
+ codec_id == AV_CODEC_ID_SIPR) {
int flavor;
- ffio_init_context(&b,
track->codec_priv.data,track->codec_priv.size,
- 0, NULL, NULL, NULL, NULL);
+ ffio_init_context(&b, track->codec_priv.data,
+ track->codec_priv.size,
+ 0, NULL, NULL, NULL, NULL);
avio_skip(&b, 22);
flavor = avio_rb16(&b);
track->audio.coded_framesize = avio_rb32(&b);
@@ -1631,7 +1669,8 @@ static int matroska_read_header(AVFormatContext *s)
track->audio.frame_size = avio_rb16(&b);
track->audio.sub_packet_size = avio_rb16(&b);
if (flavor <= 0 || track->audio.coded_framesize <= 0 ||
- track->audio.sub_packet_h <= 0 || track->audio.frame_size <= 0
||
+ track->audio.sub_packet_h <= 0 ||
+ track->audio.frame_size <= 0 ||
track->audio.sub_packet_size <= 0)
return AVERROR_INVALIDDATA;
track->audio.buf = av_malloc(track->audio.frame_size *
track->audio.sub_packet_h);
@@ -1656,7 +1695,8 @@ static int matroska_read_header(AVFormatContext *s)
if (track->time_scale < 0.01)
track->time_scale = 1.0;
- avpriv_set_pts_info(st, 64, matroska->time_scale*track->time_scale,
1000*1000*1000); /* 64 bit pts in ns */
+ avpriv_set_pts_info(st, 64, matroska->time_scale * track->time_scale,
+ 1000 * 1000 * 1000); /* 64 bit pts in ns */
st->codec->codec_id = codec_id;
st->start_time = 0;
@@ -1670,13 +1710,13 @@ static int matroska_read_header(AVFormatContext *s)
st->disposition |= AV_DISPOSITION_FORCED;
if (!st->codec->extradata) {
- if(extradata){
+ if (extradata) {
st->codec->extradata = extradata;
st->codec->extradata_size = extradata_size;
- } else if(track->codec_priv.data && track->codec_priv.size > 0){
+ } 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)
+ if (st->codec->extradata == NULL)
return AVERROR(ENOMEM);
st->codec->extradata_size = track->codec_priv.size;
memcpy(st->codec->extradata,
@@ -1688,12 +1728,12 @@ static int matroska_read_header(AVFormatContext *s)
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->codec->codec_tag = track->video.fourcc;
- st->codec->width = track->video.pixel_width;
- st->codec->height = track->video.pixel_height;
+ st->codec->width = track->video.pixel_width;
+ st->codec->height = track->video.pixel_height;
av_reduce(&st->sample_aspect_ratio.num,
&st->sample_aspect_ratio.den,
st->codec->height * track->video.display_width,
- st->codec-> width * track->video.display_height,
+ st->codec->width * track->video.display_height,
255);
if (st->codec->codec_id != AV_CODEC_ID_H264 &&
st->codec->codec_id != AV_CODEC_ID_HEVC)
@@ -1703,11 +1743,11 @@ static int matroska_read_header(AVFormatContext *s)
1000000000, track->default_duration, 30000);
}
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
- st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
+ st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->sample_rate = track->audio.out_samplerate;
- st->codec->channels = track->audio.channels;
+ st->codec->channels = track->audio.channels;
if (st->codec->codec_id != AV_CODEC_ID_AAC)
- st->need_parsing = AVSTREAM_PARSE_HEADERS;
+ st->need_parsing = AVSTREAM_PARSE_HEADERS;
} else if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE) {
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
if (st->codec->codec_id == AV_CODEC_ID_SSA)
@@ -1716,7 +1756,7 @@ static int matroska_read_header(AVFormatContext *s)
}
attachements = attachements_list->elem;
- for (j=0; j<attachements_list->nb_elem; j++) {
+ for (j = 0; j < attachements_list->nb_elem; j++) {
if (!(attachements[j].filename && attachements[j].mime &&
attachements[j].bin.data && attachements[j].bin.size > 0)) {
av_log(matroska->ctx, AV_LOG_ERROR, "incomplete attachment\n");
@@ -1724,17 +1764,18 @@ static int matroska_read_header(AVFormatContext *s)
AVStream *st = avformat_new_stream(s, NULL);
if (st == NULL)
break;
- av_dict_set(&st->metadata, "filename",attachements[j].filename, 0);
+ av_dict_set(&st->metadata, "filename", attachements[j].filename,
0);
av_dict_set(&st->metadata, "mimetype", attachements[j].mime, 0);
- st->codec->codec_id = AV_CODEC_ID_NONE;
+ st->codec->codec_id = AV_CODEC_ID_NONE;
st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
st->codec->extradata = av_malloc(attachements[j].bin.size);
- if(st->codec->extradata == NULL)
+ if (st->codec->extradata == NULL)
break;
st->codec->extradata_size = attachements[j].bin.size;
- memcpy(st->codec->extradata, attachements[j].bin.data,
attachements[j].bin.size);
+ memcpy(st->codec->extradata, attachements[j].bin.data,
+ attachements[j].bin.size);
- for (i=0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
+ for (i = 0; ff_mkv_mime_tags[i].id != AV_CODEC_ID_NONE; i++) {
if (!strncmp(ff_mkv_mime_tags[i].str, attachements[j].mime,
strlen(ff_mkv_mime_tags[i].str))) {
st->codec->codec_id = ff_mkv_mime_tags[i].id;
@@ -1746,15 +1787,16 @@ static int matroska_read_header(AVFormatContext *s)
}
chapters = chapters_list->elem;
- 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)) {
+ 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 =
- avpriv_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
- chapters[i].start, chapters[i].end,
- chapters[i].title);
+ avpriv_new_chapter(s, chapters[i].uid,
+ (AVRational) {1, 1000000000 },
+ chapters[i].start, chapters[i].end,
+ chapters[i].title);
av_dict_set(&chapters[i].chapter->metadata,
- "title", chapters[i].title, 0);
+ "title", chapters[i].title, 0);
max_start = chapters[i].start;
}
@@ -1810,7 +1852,7 @@ static void matroska_clear_queue(MatroskaDemuxContext
*matroska)
}
static int matroska_parse_laces(MatroskaDemuxContext *matroska, uint8_t **buf,
- int* buf_size, int type,
+ int *buf_size, int type,
uint32_t **lace_buf, int *laces)
{
int res = 0, n, size = *buf_size;
@@ -1828,9 +1870,9 @@ static int matroska_parse_laces(MatroskaDemuxContext
*matroska, uint8_t **buf,
}
assert(size > 0);
- *laces = *data + 1;
- data += 1;
- size -= 1;
+ *laces = *data + 1;
+ data += 1;
+ size -= 1;
lace_size = av_mallocz(*laces * sizeof(int));
if (!lace_size)
return AVERROR(ENOMEM);
@@ -1845,10 +1887,10 @@ static int matroska_parse_laces(MatroskaDemuxContext
*matroska, uint8_t **buf,
res = AVERROR_EOF;
break;
}
- temp = *data;
+ temp = *data;
lace_size[n] += temp;
- data += 1;
- size -= 1;
+ data += 1;
+ size -= 1;
if (temp != 0xff)
break;
}
@@ -1923,12 +1965,12 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext
*matroska,
uint64_t timecode, uint64_t duration,
int64_t pos)
{
- int a = st->codec->block_align;
+ int a = st->codec->block_align;
int sps = track->audio.sub_packet_size;
int cfs = track->audio.coded_framesize;
- int h = track->audio.sub_packet_h;
- int y = track->audio.sub_packet_cnt;
- int w = track->audio.frame_size;
+ int h = track->audio.sub_packet_h;
+ int y = track->audio.sub_packet_cnt;
+ int w = track->audio.frame_size;
int x;
if (!track->audio.pkt_cnt) {
@@ -1940,24 +1982,25 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext
*matroska,
"Corrupt int4 RM-style audio packet size\n");
return AVERROR_INVALIDDATA;
}
- for (x=0; x<h/2; x++)
- memcpy(track->audio.buf+x*2*w+y*cfs,
- data+x*cfs, cfs);
+ for (x = 0; x < h / 2; x++)
+ memcpy(track->audio.buf + x * 2 * w + y * cfs,
+ data + x * cfs, cfs);
} else if (st->codec->codec_id == AV_CODEC_ID_SIPR) {
if (size < w) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Corrupt sipr RM-style audio packet size\n");
return AVERROR_INVALIDDATA;
}
- memcpy(track->audio.buf + y*w, data, w);
+ memcpy(track->audio.buf + y * w, data, w);
} else {
if (size < sps * w / sps) {
av_log(matroska->ctx, AV_LOG_ERROR,
"Corrupt generic RM-style audio packet size\n");
return AVERROR_INVALIDDATA;
}
- for (x=0; x<w/sps; x++)
- memcpy(track->audio.buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)),
data+x*sps, sps);
+ for (x = 0; x < w / sps; x++)
+ memcpy(track->audio.buf + sps * (h * x + ((h + 1) / 2) * (y &
1) + (y >> 1)),
+ data + x * sps, sps);
}
if (++track->audio.sub_packet_cnt >= h) {
@@ -1971,13 +2014,12 @@ static int matroska_parse_rm_audio(MatroskaDemuxContext
*matroska,
while (track->audio.pkt_cnt) {
AVPacket *pkt = av_mallocz(sizeof(AVPacket));
av_new_packet(pkt, a);
- memcpy(pkt->data, track->audio.buf
- + a * (h*w / a - track->audio.pkt_cnt--), a);
+ memcpy(pkt->data, track->audio.buf + a * (h * w / a -
track->audio.pkt_cnt--), a);
pkt->pts = track->audio.buf_timecode;
track->audio.buf_timecode = AV_NOPTS_VALUE;
pkt->pos = pos;
pkt->stream_index = st->index;
- dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
+ dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
}
return 0;
@@ -2038,16 +2080,16 @@ static int matroska_parse_wavpack(MatroskaTrack *track,
uint8_t *src,
dst = tmp;
dstlen += blocksize + 32;
- AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
- AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
- AV_WL16(dst + offset + 8, ver); // version
+ AV_WL32(dst + offset, MKTAG('w', 'v', 'p', 'k')); // tag
+ AV_WL32(dst + offset + 4, blocksize + 24); // blocksize - 8
+ AV_WL16(dst + offset + 8, ver); // version
AV_WL16(dst + offset + 10, 0); //
track/index_no
AV_WL32(dst + offset + 12, 0); // total samples
AV_WL32(dst + offset + 16, 0); // block index
AV_WL32(dst + offset + 20, samples); // number of
samples
AV_WL32(dst + offset + 24, flags); // flags
AV_WL32(dst + offset + 28, crc); // crc
- memcpy (dst + offset + 32, src, blocksize); // block data
+ memcpy(dst + offset + 32, src, blocksize); // block data
src += blocksize;
srclen -= blocksize;
@@ -2138,7 +2180,7 @@ static int matroska_parse_frame(MatroskaDemuxContext
*matroska,
st->codec->codec_id == AV_CODEC_ID_SSA)
matroska_merge_packets(matroska->prev_pkt, pkt);
else {
- dynarray_add(&matroska->packets,&matroska->num_packets,pkt);
+ dynarray_add(&matroska->packets, &matroska->num_packets, pkt);
matroska->prev_pkt = pkt;
}
@@ -2173,7 +2215,7 @@ static int matroska_parse_block(MatroskaDemuxContext
*matroska, uint8_t *data,
track = matroska_find_track_by_num(matroska, num);
if (!track || !track->stream) {
av_log(matroska->ctx, AV_LOG_INFO,
- "Invalid stream %"PRIu64" or size %u\n", num, size);
+ "Invalid stream %" PRIu64 " or size %u\n", num, size);
return AVERROR_INVALIDDATA;
} else if (size <= 3)
return 0;
@@ -2188,14 +2230,15 @@ static int matroska_parse_block(MatroskaDemuxContext
*matroska, uint8_t *data,
if (is_keyframe == -1)
is_keyframe = flags & 0x80 ? AV_PKT_FLAG_KEY : 0;
- if (cluster_time != (uint64_t)-1
- && (block_time >= 0 || cluster_time >= -block_time)) {
+ if (cluster_time != (uint64_t)-1 &&
+ (block_time >= 0 || cluster_time >= -block_time)) {
timecode = cluster_time + block_time;
- if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE
- && timecode < track->end_timecode)
+ if (track->type == MATROSKA_TRACK_TYPE_SUBTITLE &&
+ timecode < track->end_timecode)
is_keyframe = 0; /* overlapping subtitles are not key frame */
if (is_keyframe)
- av_add_index_entry(st, cluster_pos, timecode,
0,0,AVINDEX_KEYFRAME);
+ av_add_index_entry(st, cluster_pos, timecode, 0, 0,
+ AVINDEX_KEYFRAME);
}
if (matroska->skip_to_keyframe && track->type !=
MATROSKA_TRACK_TYPE_SUBTITLE) {
@@ -2217,7 +2260,7 @@ static int matroska_parse_block(MatroskaDemuxContext
*matroska, uint8_t *data,
"Incorrect block_duration, possibly corrupted container");
}
} else {
- duration = track->default_duration / matroska->time_scale;
+ duration = track->default_duration / matroska->time_scale;
block_duration = duration * laces;
}
@@ -2230,14 +2273,12 @@ static int matroska_parse_block(MatroskaDemuxContext
*matroska, uint8_t *data,
st->codec->codec_id == AV_CODEC_ID_COOK ||
st->codec->codec_id == AV_CODEC_ID_SIPR ||
st->codec->codec_id == AV_CODEC_ID_ATRAC3) &&
- st->codec->block_align && track->audio.sub_packet_size) {
-
+ st->codec->block_align && track->audio.sub_packet_size) {
res = matroska_parse_rm_audio(matroska, track, st, data,
lace_size[n],
timecode, duration, pos);
if (res)
goto end;
-
} else {
res = matroska_parse_frame(matroska, track, st, data, lace_size[n],
timecode, duration,
@@ -2288,14 +2329,16 @@ static int
matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska)
if (!res &&
matroska->current_cluster_num_blocks <
- matroska->current_cluster.blocks.nb_elem) {
+ 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 : -1;
+ int is_keyframe = blocks[i].non_simple
+ ? !blocks[i].reference
+ : -1;
if (!blocks[i].non_simple)
blocks[i].duration = AV_NOPTS_VALUE;
res = matroska_parse_block(matroska,
@@ -2307,7 +2350,8 @@ static int
matroska_parse_cluster_incremental(MatroskaDemuxContext *matroska)
}
}
- if (res < 0) matroska->done = 1;
+ if (res < 0)
+ matroska->done = 1;
return res;
}
@@ -2327,16 +2371,18 @@ static int matroska_parse_cluster(MatroskaDemuxContext
*matroska)
res = ebml_parse(matroska, matroska_clusters, &cluster);
blocks_list = &cluster.blocks;
blocks = blocks_list->elem;
- for (i=0; i<blocks_list->nb_elem && !res; i++)
+ for (i = 0; i < blocks_list->nb_elem && !res; i++)
if (blocks[i].bin.size > 0 && blocks[i].bin.data) {
- int is_keyframe = blocks[i].non_simple ? !blocks[i].reference : -1;
+ int is_keyframe = blocks[i].non_simple
+ ? !blocks[i].reference
+ : -1;
if (!blocks[i].non_simple)
blocks[i].duration = AV_NOPTS_VALUE;
- res=matroska_parse_block(matroska,
- blocks[i].bin.data, blocks[i].bin.size,
- blocks[i].bin.pos, cluster.timecode,
- blocks[i].duration, is_keyframe,
- pos);
+ res = matroska_parse_block(matroska,
+ blocks[i].bin.data, blocks[i].bin.size,
+ blocks[i].bin.pos, cluster.timecode,
+ blocks[i].duration, is_keyframe,
+ pos);
}
ebml_free(matroska_cluster, &cluster);
return res;
@@ -2382,7 +2428,8 @@ static int matroska_read_seek(AVFormatContext *s, int
stream_index,
timestamp = FFMAX(timestamp, st->index_entries[0].timestamp);
if ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
- avio_seek(s->pb, st->index_entries[st->nb_index_entries-1].pos,
SEEK_SET);
+ avio_seek(s->pb, st->index_entries[st->nb_index_entries - 1].pos,
+ SEEK_SET);
matroska->current_id = 0;
while ((index = av_index_search_timestamp(st, timestamp, flags)) < 0) {
matroska_clear_queue(matroska);
@@ -2396,17 +2443,19 @@ static int matroska_read_seek(AVFormatContext *s, int
stream_index,
return 0;
index_min = index;
- for (i=0; i < matroska->tracks.nb_elem; i++) {
- tracks[i].audio.pkt_cnt = 0;
+ for (i = 0; i < matroska->tracks.nb_elem; i++) {
+ tracks[i].audio.pkt_cnt = 0;
tracks[i].audio.sub_packet_cnt = 0;
- tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
- tracks[i].end_timecode = 0;
- if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE
- && !tracks[i].stream->discard != AVDISCARD_ALL) {
- index_sub = av_index_search_timestamp(tracks[i].stream,
st->index_entries[index].timestamp, AVSEEK_FLAG_BACKWARD);
- if (index_sub >= 0
- && st->index_entries[index_sub].pos <
st->index_entries[index_min].pos
- && st->index_entries[index].timestamp -
st->index_entries[index_sub].timestamp < 30000000000/matroska->time_scale)
+ tracks[i].audio.buf_timecode = AV_NOPTS_VALUE;
+ tracks[i].end_timecode = 0;
+ if (tracks[i].type == MATROSKA_TRACK_TYPE_SUBTITLE &&
+ !tracks[i].stream->discard != AVDISCARD_ALL) {
+ index_sub = av_index_search_timestamp(
+ tracks[i].stream, st->index_entries[index].timestamp,
+ AVSEEK_FLAG_BACKWARD);
+ if (index_sub >= 0 &&
+ st->index_entries[index_sub].pos <
st->index_entries[index_min].pos &&
+ st->index_entries[index].timestamp -
st->index_entries[index_sub].timestamp < 30000000000 / matroska->time_scale)
index_min = index_sub;
}
}
@@ -2428,7 +2477,7 @@ static int matroska_read_close(AVFormatContext *s)
matroska_clear_queue(matroska);
- for (n=0; n < matroska->tracks.nb_elem; n++)
+ for (n = 0; n < matroska->tracks.nb_elem; n++)
if (tracks[n].type == MATROSKA_TRACK_TYPE_AUDIO)
av_free(tracks[n].audio.buf);
ebml_free(matroska_cluster, &matroska->current_cluster);
--
1.8.3.2
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
