Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

* simplified parameters for parse routines

Browse Source 
Originally committed as revision 1816 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Zdenek Kabelac 22 years ago
parent 5d23497493
commit b6a17df438
1 changed files with 123 additions and 128 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 231
      libavformat/mov.c

231
libavformat/mov.c
Unescape View File

@ -79,12 +79,14 @@ void print_atom(const char *str, uint32_t type, uint64_t offset, uint64_t size)
(unsigned int)size);
assert((unsigned int)size < 0x7fffffff);// catching errors
}
#else
#define print_atom(a,b,c,d)
#endif
/* some streams in QT (and in MP4 mostly) aren't either video nor audio */
/* so we first list them as this, then clean up the list of streams we give back, */
/* getting rid of these */
#define CODEC_TYPE_MOV_OTHER 2
#define CODEC_TYPE_MOV_OTHER (enum CodecType) 2
static const CodecTag mov_video_tags[] = {
/* { CODEC_ID_, MKTAG('c', 'v', 'i', 'd') }, *//* Cinepak */
@ -197,6 +199,8 @@ typedef struct {
uint8_t *sl_config;
} MOV_esds_t;
struct MOVParseTableEntry;
typedef struct MOVStreamContext {
int ffindex; /* the ffmpeg stream id */
int is_ff_stream; /* Is this stream presented to ffmpeg ? i.e. is this an audio or video stream ? */
@ -235,11 +239,11 @@ typedef struct MOVContext {
int64_t next_chunk_offset;
MOVStreamContext *partial; /* != 0 : there is still to read in the current chunk */
const struct MOVParseTableEntry *parse_table; /* could be eventually used to change the table */
/* NOTE: for recursion save to/ restore from local variable! */
} MOVContext;
struct MOVParseTableEntry;
/* XXX: it's the first time I make a recursive parser I think... sorry if it's ugly :P */
/* those functions parse an atom */
@ -248,37 +252,33 @@ struct MOVParseTableEntry;
0: continue to parse next atom
-1: error occured, exit
*/
typedef int (*mov_parse_function)(const struct MOVParseTableEntry *parse_table,
typedef int (*mov_parse_function)(MOVContext *ctx,
ByteIOContext *pb,
uint32_t atom_type,
int64_t atom_offset, /* after the size and type field (and eventually the extended size) */
int64_t atom_size, /* total size (excluding the size and type fields) */
void *param);
int64_t atom_size); /* total size (excluding the size and type fields) */
/* links atom IDs to parse functions */
typedef struct MOVParseTableEntry {
uint32_t type;
mov_parse_function func;
} MOVParseTableEntry;
static const MOVParseTableEntry mov_default_parse_table[];
static int parse_leaf(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_leaf(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
#ifdef DEBUG
print_atom("leaf", atom_type, atom_offset, atom_size);
#endif
if(atom_size>1)
url_fskip(pb, atom_size);
/* url_seek(pb, atom_offset+atom_size, SEEK_SET); */
return 0;
}
static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_default(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
uint32_t type, foo=0;
uint64_t offset, size;
uint64_t total_size = 0;
int64_t total_size = 0;
int i;
int err = 0;
foo=0;
@ -311,19 +311,24 @@ static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *p
if (size <= 8)
break;
}
for (i=0; parse_table[i].type != 0L && parse_table[i].type != type; i++)
for (i=0; c->parse_table[i].type != 0L && c->parse_table[i].type != type; i++)
/* empty */;
size -= 8;
// printf(" i=%ld\n", i);
if (parse_table[i].type == 0) { /* skip leaf atoms data */
if (c->parse_table[i].type == 0) { /* skip leaf atoms data */
// url_seek(pb, atom_offset+atom_size, SEEK_SET);
#ifdef DEBUG
print_atom("unknown", type, offset, size);
#endif
url_fskip(pb, size);
} else
err = (parse_table[i].func)(parse_table, pb, type, offset, size, param);
} else {
#ifdef DEBUG
//char b[5] = { type & 0xff, (type >> 8) & 0xff, (type >> 16) & 0xff, (type >> 24) & 0xff, 0 };
//print_atom(b, type, offset, size);
#endif
err = (c->parse_table[i].func)(c, pb, type, offset, size);
}
offset+=size;
total_size+=size;
@ -340,19 +345,15 @@ static int parse_default(const MOVParseTableEntry *parse_table, ByteIOContext *p
return err;
}
static int parse_ctab(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_ctab(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
url_fskip(pb, atom_size); // for now
return 0;
}
static int parse_mvhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_mvhd(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
#ifdef DEBUG
print_atom("mvhd", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
get_byte(pb); /* version */
get_byte(pb); get_byte(pb); get_byte(pb); /* flags */
@ -384,16 +385,13 @@ static int parse_mvhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
}
/* this atom should contain all header atoms */
static int parse_moov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_moov(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
int err;
MOVContext *c;
#ifdef DEBUG
print_atom("moov", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
err = parse_default(parse_table, pb, atom_type, atom_offset, atom_size, param);
err = parse_default(c, pb, atom_type, atom_offset, atom_size);
/* we parsed the 'moov' atom, we can terminate the parsing as soon as we find the 'mdat' */
/* so we don't parse the whole file if over a network */
c->found_moov=1;
@ -403,13 +401,9 @@ static int parse_moov(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
}
/* this atom contains actual media data */
static int parse_mdat(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_mdat(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
#ifdef DEBUG
print_atom("mdat", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
if(atom_size == 0) /* wrong one (MP4) */
return 0;
@ -425,10 +419,11 @@ static int parse_mdat(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
/* this atom should be null (from specs), but some buggy files put the 'moov' atom inside it... */
/* like the files created with Adobe Premiere 5.0, for samples see */
/* http://graphics.tudelft.nl/~wouter/publications/soundtests/ */
static int parse_wide(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_wide(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
int err;
uint32_t type;
#ifdef DEBUG
print_atom("wide", atom_type, atom_offset, atom_size);
debug_indent++;
@ -444,44 +439,42 @@ static int parse_wide(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
url_fskip(pb, atom_size - 8);
return 0;
}
err = parse_mdat(parse_table, pb, type, atom_offset + 8, atom_size - 8, param);
err = parse_mdat(c, pb, type, atom_offset + 8, atom_size - 8);
#ifdef DEBUG
debug_indent--;
#endif
return err;
}
static int parse_trak(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_trak(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("trak", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = av_new_stream(c->fc, c->fc->nb_streams);
if (!st) return -2;
sc = av_malloc(sizeof(MOVStreamContext));
memset(sc, 0, sizeof(MOVStreamContext));
sc = (MOVStreamContext*) av_mallocz(sizeof(MOVStreamContext));
if (!sc) {
av_free(st);
return -1;
}
sc->sample_to_chunk_index = -1;
st->priv_data = sc;
st->codec.codec_type = CODEC_TYPE_MOV_OTHER;
st->time_length = (c->duration * 1000) / c->time_scale; // time in miliseconds
c->streams[c->fc->nb_streams-1] = sc;
return parse_default(parse_table, pb, atom_type, atom_offset, atom_size, param);
return parse_default(c, pb, atom_type, atom_offset, atom_size);
}
static int parse_tkhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_tkhd(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
AVStream *st;
#ifdef DEBUG
print_atom("tkhd", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
get_byte(pb); /* version */
@ -517,15 +510,12 @@ static int parse_tkhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_mdhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_mdhd(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
AVStream *st;
#ifdef DEBUG
print_atom("mdhd", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
get_byte(pb); /* version */
@ -549,18 +539,16 @@ static int parse_mdhd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_hdlr(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int len = 0;
char *buf;
uint8_t *buf;
uint32_t type;
AVStream *st;
uint32_t ctype;
#ifdef DEBUG
print_atom("hdlr", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
get_byte(pb); /* version */
@ -623,13 +611,16 @@ static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
} else {
/* .mov: PASCAL string */
len = get_byte(pb);
buf = av_malloc(len+1);
buf = (uint8_t*) av_malloc(len+1);
if (buf) {
get_buffer(pb, buf, len);
buf[len] = '\0';
#ifdef DEBUG
buf[len] = '\0';
printf("**buf='%s'\n", buf);
#endif
av_free(buf);
} else
url_fskip(pb, len);
}
#if 0
len = get_byte(pb);
@ -637,12 +628,15 @@ static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
if(len < 32) {
/* assume that it is a Pascal like string */
buf = av_malloc(len+1);
if (buf) {
get_buffer(pb, buf, len);
buf[len] = '\0';
#ifdef DEBUG
printf("**buf='%s'\n", buf);
#endif
av_free(buf);
} else
url_fskip(pb, len)l
} else {
/* MP4 string */
for(;;) {
@ -691,17 +685,15 @@ static inline unsigned int get_be24(ByteIOContext *s)
return val;
}
static int parse_esds(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_esds(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
int64_t start_pos = url_ftell(pb);
MOVContext *c = (MOVContext *)param;
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = (MOVStreamContext *)st->priv_data;
int tag, len;
#ifdef DEBUG
print_atom("esds", atom_type, atom_offset, atom_size);
#endif
/* Well, broken but suffisant for some MP4 streams */
get_be32(pb); /* version + flags */
@ -725,7 +717,7 @@ static int parse_esds(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
#ifdef DEBUG
printf("Specific MPEG4 header len=%d\n", len);
#endif
sc->header_data = av_mallocz(len);
sc->header_data = (uint8_t*) av_mallocz(len);
if (sc->header_data) {
get_buffer(pb, sc->header_data, len);
sc->header_len = len;
@ -737,17 +729,15 @@ static int parse_esds(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_stsd(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int entries, size, frames_per_sample, id;
int entries, size, frames_per_sample;
uint32_t format;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("stsd", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
sc = (MOVStreamContext *)st->priv_data;
@ -757,6 +747,7 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
entries = get_be32(pb);
while(entries--) {
enum CodecID id;
size = get_be32(pb); /* size */
format = get_le32(pb); /* data format */
@ -806,7 +797,7 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
#ifdef DEBUG
printf("frames/samples = %d\n", frames_per_sample);
#endif
get_buffer(pb, st->codec.codec_name, 32); /* codec name */
get_buffer(pb, (uint8_t *)st->codec.codec_name, 32); /* codec name */
st->codec.bits_per_sample = get_be16(pb); /* depth */
st->codec.color_table_id = get_be16(pb); /* colortable id */
@ -886,7 +877,7 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
url_fskip(pb, size);
}
#else
parse_default(mov_default_parse_table, pb, 0L, 0LL, size, param);
parse_default(c, pb, 0L, 0LL, size);
#endif
} else {
get_be16(pb); /* version */
@ -902,11 +893,18 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
get_be16(pb); /* packet size = 0 */
st->codec.sample_rate = ((get_be32(pb) >> 16));
printf("CODECID %d %d %.4s\n", st->codec.codec_id, CODEC_ID_PCM_S16BE, (char*)&format);
if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
switch (st->codec.codec_id) {
case CODEC_ID_PCM_S16BE:
if (st->codec.bits_per_sample == 8)
st->codec.codec_id = CODEC_ID_PCM_S8;
st->codec.bit_rate = st->codec.sample_rate;
/* fall */
case CODEC_ID_PCM_U8:
st->codec.bit_rate = st->codec.sample_rate * 8;
break;
default:
;
}
get_be32(pb); /* samples per packet */
get_be32(pb); /* bytes per packet */
@ -921,13 +919,14 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
fcc = get_le32(pb); // evaw
//printf("%x %.4s %d\n", fcc, (char*)&fcc, st->codec.extradata_size);
st->codec.extradata = av_mallocz(st->codec.extradata_size);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
if (st->codec.extradata)
get_buffer(pb, st->codec.extradata, st->codec.extradata_size); // FIXME url_fskip
url_fskip(pb, size-(16 + 20 + 16 + 8 + st->codec.extradata_size));
}
else
url_fskip(pb, size-(16 + 20 + 16));
#else
parse_default(mov_default_parse_table, pb, 0L, 0LL, size - (16 + 20 + 16 + 8), param);
parse_default(c, pb, 0L, 0LL, size - (16 + 20 + 16 + 8));
#endif
}
}
@ -943,16 +942,14 @@ static int parse_stsd(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_stco(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int entries, i;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("stco", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
sc = (MOVStreamContext *)st->priv_data;
@ -961,7 +958,9 @@ static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
entries = get_be32(pb);
sc->chunk_count = entries;
sc->chunk_offsets = av_malloc(entries * sizeof(int64_t));
sc->chunk_offsets = (int64_t*) av_malloc(entries * sizeof(int64_t));
if (!sc->chunk_offsets)
return -1;
if(atom_type == MKTAG('s', 't', 'c', 'o')) {
for(i=0; i<entries; i++) {
sc->chunk_offsets[i] = get_be32(pb);
@ -982,16 +981,14 @@ static int parse_stco(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_stsc(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_stsc(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int entries, i;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("stsc", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
sc = (MOVStreamContext *)st->priv_data;
@ -1003,7 +1000,9 @@ static int parse_stsc(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
printf("track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
#endif
sc->sample_to_chunk_sz = entries;
sc->sample_to_chunk = av_malloc(entries * sizeof(MOV_sample_to_chunk_tbl));
sc->sample_to_chunk = (MOV_sample_to_chunk_tbl*) av_malloc(entries * sizeof(MOV_sample_to_chunk_tbl));
if (!sc->sample_to_chunk)
return -1;
for(i=0; i<entries; i++) {
sc->sample_to_chunk[i].first = get_be32(pb);
sc->sample_to_chunk[i].count = get_be32(pb);
@ -1015,16 +1014,14 @@ printf("track[%i].stsc.entries = %i\n", c->fc->nb_streams-1, entries);
return 0;
}
static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_stsz(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int entries, i;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("stsz", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
sc = (MOVStreamContext *)st->priv_data;
@ -1039,7 +1036,9 @@ static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
#endif
if(sc->sample_size)
return 0; /* there isn't any table following */
sc->sample_sizes = av_malloc(entries * sizeof(long));
sc->sample_sizes = (long*) av_malloc(entries * sizeof(long));
if (!sc->sample_sizes)
return -1;
for(i=0; i<entries; i++) {
sc->sample_sizes[i] = get_be32(pb);
#ifdef DEBUG
@ -1049,16 +1048,14 @@ static int parse_stsz(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
return 0;
}
static int parse_stts(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_stts(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
int entries, i;
AVStream *st;
MOVStreamContext *sc;
#ifdef DEBUG
print_atom("stts", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
st = c->fc->streams[c->fc->nb_streams-1];
sc = (MOVStreamContext *)st->priv_data;
@ -1091,18 +1088,15 @@ static int null_read_packet(void *opaque, uint8_t *buf, int buf_size)
return -1;
}
static int parse_cmov(const MOVParseTableEntry *parse_table, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size, void *param)
static int parse_cmov(MOVContext *c, ByteIOContext *pb, uint32_t atom_type, int64_t atom_offset, int64_t atom_size)
{
MOVContext *c;
ByteIOContext ctx;
char *cmov_data;
unsigned char *moov_data; /* uncompressed data */
uint8_t *cmov_data;
uint8_t *moov_data; /* uncompressed data */
long cmov_len, moov_len;
int ret;
#ifdef DEBUG
print_atom("cmov", atom_type, atom_offset, atom_size);
#endif
c = (MOVContext *)param;
get_be32(pb); /* dcom atom */
if (get_le32(pb) != MKTAG( 'd', 'c', 'o', 'm' ))
@ -1117,21 +1111,21 @@ static int parse_cmov(const MOVParseTableEntry *parse_table, ByteIOContext *pb,
moov_len = get_be32(pb); /* uncompressed size */
cmov_len = atom_size - 6 * 4;
cmov_data = av_malloc(cmov_len);
cmov_data = (uint8_t *) av_malloc(cmov_len);
if (!cmov_data)
return -1;
moov_data = av_malloc(moov_len);
moov_data = (uint8_t *) av_malloc(moov_len);
if (!moov_data) {
av_free(cmov_data);
return -1;
}
get_buffer(pb, cmov_data, cmov_len);
if(uncompress (moov_data, &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
return -1;
if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, null_read_packet, NULL, NULL) != 0)
return -1;
ctx.buf_end = ctx.buffer + moov_len;
ret = parse_default(parse_table, &ctx, MKTAG( 'm', 'o', 'o', 'v' ), 0, moov_len, param);
ret = parse_default(c, &ctx, MKTAG( 'm', 'o', 'o', 'v' ), 0, moov_len);
av_free(moov_data);
av_free(cmov_data);
return ret;
@ -1235,7 +1229,7 @@ static inline uint32_t to_be32(uint8_t *buf)
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
/* XXX: is it suffisant ? */
/* XXX: is it sufficient ? */
static int mov_probe(AVProbeData *p)
{
unsigned int offset;
@ -1271,12 +1265,13 @@ static int mov_probe(AVProbeData *p)
static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
MOVContext *mov = s->priv_data;
MOVContext *mov = (MOVContext *) s->priv_data;
ByteIOContext *pb = &s->pb;
int i, j, nb, err;
int64_t size;
mov->fc = s;
mov->parse_table = mov_default_parse_table;
#if 0
/* XXX: I think we should auto detect */
if(s->iformat->name[1] == 'p')
@ -1292,7 +1287,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
#endif
/* check MOV header */
err = parse_default(mov_default_parse_table, pb, 0L, 0LL, size, mov);
err = parse_default(mov, pb, 0L, 0LL, size);
if(err<0 || (!mov->found_moov || !mov->found_mdat)) {
puts("header not found !!!");
exit(1);
@ -1342,7 +1337,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
/* XXX:remove useless commented code sometime */
static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)
{
MOVContext *mov = s->priv_data;
MOVContext *mov = (MOVContext *) s->priv_data;
MOVStreamContext *sc;
int64_t offset = 0x0FFFFFFFFFFFFFFF;
int i;
@ -1472,7 +1467,7 @@ readchunk:
static int mov_read_close(AVFormatContext *s)
{
int i;
MOVContext *mov = s->priv_data;
MOVContext *mov = (MOVContext *) s->priv_data;
for(i=0; i<mov->total_streams; i++)
mov_free_stream_context(mov->streams[i]);
for(i=0; i<s->nb_streams; i++)

Write Preview
Loading…
Cancel
Save