#include "riff.h"
#include "isom.h"
#include "dv.h"
+#include "libavcodec/mpeg4audio.h"
+#include "libavcodec/mpegaudiodata.h"
#ifdef CONFIG_ZLIB
#include <zlib.h>
unsigned int bytes_per_frame;
unsigned int samples_per_frame;
int dv_audio_container;
- int pseudo_stream_id;
+ int pseudo_stream_id; ///< -1 means demux all ids
int16_t audio_cid; ///< stsd audio compression id
unsigned drefs_count;
MOV_dref_t *drefs;
/* those functions parse an atom */
/* return code:
- 1: found what I wanted, exit
0: continue to parse next atom
<0: error occurred, exit
*/
#define MP4DecConfigDescrTag 0x04
#define MP4DecSpecificDescrTag 0x05
+static const AVCodecTag mp4_audio_types[] = {
+ { CODEC_ID_MP3ON4, 29 }, /* old mp3on4 draft */
+ { CODEC_ID_MP3ON4, 32 }, /* layer 1 */
+ { CODEC_ID_MP3ON4, 33 }, /* layer 2 */
+ { CODEC_ID_MP3ON4, 34 }, /* layer 3 */
+ { CODEC_ID_NONE, 0 },
+};
+
static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
return AVERROR(ENOMEM);
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
- /* from mplayer */
- if ((*st->codec->extradata >> 3) == 29) {
- st->codec->codec_id = CODEC_ID_MP3ON4;
+ if (st->codec->codec_id == CODEC_ID_AAC) {
+ MPEG4AudioConfig cfg;
+ ff_mpeg4audio_get_config(&cfg, st->codec->extradata,
+ st->codec->extradata_size);
+ if (cfg.chan_config > 7)
+ return -1;
+ st->codec->channels = ff_mpeg4audio_channels[cfg.chan_config];
+ if (cfg.object_type == 29 && cfg.sampling_index < 3) // old mp3on4
+ st->codec->sample_rate = ff_mpa_freq_tab[cfg.sampling_index];
+ else
+ st->codec->sample_rate = cfg.sample_rate; // ext sample rate ?
+ dprintf(c->fc, "mp4a config channels %d obj %d ext obj %d "
+ "sample rate %d ext sample rate %d\n", st->codec->channels,
+ cfg.object_type, cfg.ext_object_type,
+ cfg.sample_rate, cfg.ext_sample_rate);
+ if (!(st->codec->codec_id = codec_get_id(mp4_audio_types,
+ cfg.object_type)))
+ st->codec->codec_id = CODEC_ID_AAC;
}
}
}
int lang;
if (version > 1)
- return 1; /* unsupported */
+ return -1; /* unsupported */
get_be24(pb); /* flags */
if (version == 1) {
{
AVStream *st = c->fc->streams[c->fc->nb_streams-1];
MOVStreamContext *sc = st->priv_data;
- int entries, frames_per_sample;
- uint32_t format;
- uint8_t codec_name[32];
-
- /* for palette traversal */
- unsigned int color_depth;
- unsigned int color_start;
- unsigned int color_count;
- unsigned int color_end;
- int color_index;
- int color_dec;
- int color_greyscale;
- const uint8_t *color_table;
- int j, pseudo_stream_id;
- unsigned char r, g, b;
+ int j, entries, pseudo_stream_id;
get_byte(pb); /* version */
get_be24(pb); /* flags */
MOV_atom_t a = { 0, 0, 0 };
offset_t start_pos = url_ftell(pb);
int size = get_be32(pb); /* size */
- format = get_le32(pb); /* data format */
+ uint32_t format = get_le32(pb); /* data format */
get_be32(pb); /* reserved */
get_be16(pb); /* reserved */
dref_id = get_be16(pb);
if (st->codec->codec_tag &&
+ st->codec->codec_tag != format &&
(c->fc->video_codec_id ? codec_get_id(codec_movvideo_tags, format) != c->fc->video_codec_id
: st->codec->codec_tag != MKTAG('j','p','e','g'))
){
/* Multiple fourcc, we skip JPEG. This is not correct, we should
* export it as a separate AVStream but this needs a few changes
* in the MOV demuxer, patch welcome. */
+ av_log(c->fc, AV_LOG_WARNING, "multiple fourcc not supported\n");
url_fskip(pb, size - (url_ftell(pb) - start_pos));
continue;
}
- sc->pseudo_stream_id= pseudo_stream_id;
+ sc->pseudo_stream_id = st->codec->codec_tag ? -1 : pseudo_stream_id;
sc->dref_id= dref_id;
st->codec->codec_tag = format;
(format >> 24) & 0xff, st->codec->codec_type);
if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
+ uint8_t codec_name[32];
+ unsigned int color_depth;
+ int color_greyscale;
+
st->codec->codec_id = id;
get_be16(pb); /* version */
get_be16(pb); /* revision level */
get_be32(pb); /* horiz resolution */
get_be32(pb); /* vert resolution */
get_be32(pb); /* data size, always 0 */
- frames_per_sample = get_be16(pb); /* frames per samples */
+ get_be16(pb); /* frames per samples */
- dprintf(c->fc, "frames/samples = %d\n", frames_per_sample);
-
- get_buffer(pb, codec_name, 32); /* codec name, pascal string (FIXME: true for mp4?) */
+ get_buffer(pb, codec_name, 32); /* codec name, pascal string */
if (codec_name[0] <= 31) {
memcpy(st->codec->codec_name, &codec_name[1],codec_name[0]);
st->codec->codec_name[codec_name[0]] = 0;
/* if the depth is 2, 4, or 8 bpp, file is palettized */
if ((color_depth == 2) || (color_depth == 4) ||
(color_depth == 8)) {
+ /* for palette traversal */
+ unsigned int color_start, color_count, color_end;
+ unsigned char r, g, b;
+
if (color_greyscale) {
+ int color_index, color_dec;
/* compute the greyscale palette */
st->codec->bits_per_sample = color_depth;
color_count = 1 << color_depth;
color_index = 0;
}
} else if (st->codec->color_table_id) {
+ const uint8_t *color_table;
/* if flag bit 3 is set, use the default palette */
color_count = 1 << color_depth;
if (color_depth == 2)
st->codec->channels= 1; /* really needed */
break;
case CODEC_ID_QCELP:
- st->codec->frame_size = sc->samples_per_frame;
- st->need_parsing= AVSTREAM_PARSE_FULL;
case CODEC_ID_AMR_NB:
+ st->codec->frame_size= sc->samples_per_frame;
st->codec->sample_rate= 8000;
st->codec->channels= 1; /* really needed */
break;
stss_index++;
}
sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample];
- dprintf(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
- "size %d, distance %d, keyframe %d\n", st->index, current_sample,
- current_offset, current_dts, sample_size, distance, keyframe);
- if(sc->sample_to_chunk[stsc_index].id - 1 == sc->pseudo_stream_id)
+ if(sc->pseudo_stream_id == -1 ||
+ sc->sample_to_chunk[stsc_index].id - 1 == sc->pseudo_stream_id) {
av_add_index_entry(st, current_offset, current_dts, sample_size, distance,
keyframe ? AVINDEX_KEYFRAME : 0);
+ dprintf(mov->fc, "AVIndex stream %d, sample %d, offset %"PRIx64", dts %"PRId64", "
+ "size %d, distance %d, keyframe %d\n", st->index, current_sample,
+ current_offset, current_dts, sample_size, distance, keyframe);
+ }
current_offset += sample_size;
assert(sc->stts_data[stts_index].duration % sc->time_rate == 0);
current_dts += sc->stts_data[stts_index].duration / sc->time_rate;
/* get chunk size, beware of alaw/ulaw/mace */
if (sc->samples_per_frame > 0 &&
(chunk_samples * sc->bytes_per_frame % sc->samples_per_frame == 0)) {
- if (sc->samples_per_frame < 1024)
+ if (sc->samples_per_frame < 160)
chunk_size = chunk_samples * sc->bytes_per_frame / sc->samples_per_frame;
else {
chunk_size = sc->bytes_per_frame;
st->codec->width= 0; /* let decoder init width/height */
st->codec->height= 0;
break;
-#ifdef CONFIG_LIBFAAD
- case CODEC_ID_AAC:
-#endif
#ifdef CONFIG_VORBIS_DECODER
case CODEC_ID_VORBIS:
#endif
- case CODEC_ID_MP3ON4:
st->codec->sample_rate= 0; /* let decoder init parameters properly */
break;
}
uint8_t *cmov_data;
uint8_t *moov_data; /* uncompressed data */
long cmov_len, moov_len;
- int ret;
+ int ret = -1;
get_be32(pb); /* dcom atom */
if (get_le32(pb) != MKTAG('d','c','o','m'))
}
get_buffer(pb, cmov_data, cmov_len);
if(uncompress (moov_data, (uLongf *) &moov_len, (const Bytef *)cmov_data, cmov_len) != Z_OK)
- return -1;
+ goto free_and_return;
if(init_put_byte(&ctx, moov_data, moov_len, 0, NULL, NULL, NULL, NULL) != 0)
- return -1;
+ goto free_and_return;
atom.type = MKTAG('m','o','o','v');
atom.offset = 0;
atom.size = moov_len;
// { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
#endif
ret = mov_read_default(c, &ctx, atom);
+free_and_return:
av_free(moov_data);
av_free(cmov_data);
return ret;
}
static const MOVParseTableEntry mov_default_parse_table[] = {
+{ MKTAG('a','v','s','s'), mov_read_extradata },
{ MKTAG('c','o','6','4'), mov_read_stco },
{ MKTAG('c','t','t','s'), mov_read_ctts }, /* composition time to sample */
{ MKTAG('d','i','n','f'), mov_read_default },
sc->sample_to_ctime_sample = 0;
}
} else {
+ AVStream *st = s->streams[sc->ffindex];
+ int64_t next_dts = (sc->current_sample < sc->sample_count) ?
+ st->index_entries[sc->current_sample].timestamp : st->duration;
+ pkt->duration = next_dts - pkt->dts;
pkt->pts = pkt->dts;
}
pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0;
AVInputFormat mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2",
- "QuickTime/MPEG4/Motion JPEG 2000 format",
+ NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
sizeof(MOVContext),
mov_probe,
mov_read_header,