static int demux_mpg_read_packet(demuxer_t *demux,int id){
int d;
int len;
int set_pts=0; // !=0 iff pts has been set to a proper value
unsigned char c=0;
unsigned long long pts=0;
unsigned long long dts=0;
int l;
int pes_ext2_subid=-1;
double stream_pts = MP_NOPTS_VALUE;
demux_stream_t *ds=NULL;
demux_packet_t* dp;
mpg_demuxer_t *priv = (mpg_demuxer_t *) demux->priv;
mp_dbg(MSGT_DEMUX,MSGL_DBG3,"demux_read_packet: %X\n",id);
// if(id==0x1F0){
// demux->synced=0; // force resync after 0x1F0
// return -1;
//}
// if(id==0x1BA) packet_start_pos=stream_tell(demux->stream);
if((id<0x1BC || id>=0x1F0) && id != 0x1FD) return -1;
if(id==0x1BE) return -1; // padding stream
if(id==0x1BF) return -1; // private2
len=stream_read_word(demux->stream);
mp_dbg(MSGT_DEMUX,MSGL_DBG3,"PACKET len=%d",len);
// if(len==62480){ demux->synced=0;return -1;} /* :) */
if(len==0 || len>MAX_PS_PACKETSIZE){
mp_dbg(MSGT_DEMUX,MSGL_DBG2,"Invalid PS packet len: %d\n",len);
return -2; // invalid packet !!!!!!
}
mpeg_pts_error=0;
if(id==0x1BC) {
parse_psm(demux, len);
return 0;
}
while(len>0){ // Skip stuFFing bytes
c=stream_read_char(demux->stream);
--len;
if(c!=0xFF)break;
}
if((c>>6)==1){ // Read (skip) STD scale & size value
// printf(" STD_scale=%d",(c>>5)&1);
d=((c&0x1F)<<8)|stream_read_char(demux->stream);
len-=2;
// printf(" STD_size=%d",d);
c=stream_read_char(demux->stream);
}
// Read System-1 stream timestamps:
if((c>>4)==2){
pts=read_mpeg_timestamp(demux->stream,c);
set_pts=1;
len-=4;
} else
if((c>>4)==3){
/*
* Read: element content length.
*/
uint64_t ebml_read_length(stream_t *s, int *length)
{
int i, j, num_ffs = 0, len_mask = 0x80;
uint64_t len;
for (i = 0, len = stream_read_char(s); i < 8 && !(len & len_mask); i++)
len_mask >>= 1;
if (i >= 8)
return EBML_UINT_INVALID;
j = i + 1;
if (length)
*length = j;
if ((int) (len &= (len_mask - 1)) == len_mask - 1)
num_ffs++;
while (i--) {
len = (len << 8) | stream_read_char(s);
if ((len & 0xFF) == 0xFF)
num_ffs++;
}
if (j == num_ffs)
return EBML_UINT_INVALID;
if (len >= 1ULL<<63) // Can happen if stream_read_char returns EOF
return EBML_UINT_INVALID;
return len;
}
static int parse_psm(demuxer_t *demux, int len) {
unsigned char c, id, type;
unsigned int plen, prog_len, es_map_len;
mpg_demuxer_t *priv = (mpg_demuxer_t *) demux->priv;
mp_dbg(MSGT_DEMUX,MSGL_V, "PARSE_PSM, len=%d\n", len);
if(! len || len > 1018)
return 0;
c = stream_read_char(demux->stream);
if(! (c & 0x80)) {
stream_skip(demux->stream, len - 1); //not yet valid, discard
return 0;
}
stream_skip(demux->stream, 1);
prog_len = stream_read_word(demux->stream); //length of program descriptors
stream_skip(demux->stream, prog_len); //.. that we ignore
es_map_len = stream_read_word(demux->stream); //length of elementary streams map
es_map_len = FFMIN(es_map_len, len - prog_len - 8); //sanity check
while(es_map_len > 0) {
type = stream_read_char(demux->stream);
id = stream_read_char(demux->stream);
if(id >= 0xB0 && id <= 0xEF && priv) {
int idoffset = id - 0xB0;
switch(type) {
case 0x1:
priv->es_map[idoffset] = VIDEO_MPEG1;
break;
case 0x2:
priv->es_map[idoffset] = VIDEO_MPEG2;
break;
case 0x3:
case 0x4:
priv->es_map[idoffset] = AUDIO_MP2;
break;
case 0x0f:
case 0x11:
priv->es_map[idoffset] = AUDIO_AAC;
break;
case 0x10:
priv->es_map[idoffset] = VIDEO_MPEG4;
break;
case 0x1b:
priv->es_map[idoffset] = VIDEO_H264;
break;
case 0x81:
priv->es_map[idoffset] = AUDIO_A52;
break;
}
mp_dbg(MSGT_DEMUX,MSGL_V, "PSM ES, id=0x%x, type=%x, stype: %x\n", id, type, priv->es_map[idoffset]);
}
plen = stream_read_word(demux->stream); //length of elementary stream descriptors
plen = FFMIN(plen, es_map_len); //sanity check
stream_skip(demux->stream, plen); //skip descriptors for now
es_map_len -= 4 + plen;
}
stream_skip(demux->stream, 4); //skip crc32
return 1;
}
inline static unsigned int stream_read_dword(const uint8_t *s)
{
unsigned int y;
y=stream_read_char(s);
y=(y<<8)|stream_read_char(s+1);
y=(y<<8)|stream_read_char(s+2);
y=(y<<8)|stream_read_char(s+3);
return y;
}
inline static uint32_t stream_read_dword(uint8_t *s)
{
uint32_t y = 0;
y = stream_read_char(s );
y = (y << 8) | stream_read_char(s + 1);
y = (y << 8) | stream_read_char(s + 2);
y = (y << 8) | stream_read_char(s + 3);
return y;
}
/*
* Read: the element content data ID.
* Return: the ID.
*/
uint32_t ebml_read_id(stream_t *s)
{
int i, len_mask = 0x80;
uint32_t id;
for (i = 0, id = stream_read_char(s); i < 4 && !(id & len_mask); i++)
len_mask >>= 1;
if (i >= 4)
return EBML_ID_INVALID;
while (i--)
id = (id << 8) | stream_read_char(s);
return id;
}
// return value:
// 0 = EOF or no stream found
// 1 = successfully read a packet
static int demux_y4m_fill_buffer(demuxer_t *demux, demux_stream_t *dsds) {
demux_stream_t *ds=demux->video;
demux_packet_t *dp;
y4m_priv_t *priv=demux->priv;
y4m_frame_info_t fi;
unsigned char *buf[3];
int err, size;
y4m_init_frame_info(&fi);
demux->filepos=stream_tell(demux->stream);
size = ((sh_video_t*)ds->sh)->disp_w*((sh_video_t*)ds->sh)->disp_h;
dp = new_demux_packet(3*size/2);
/* swap U and V components */
buf[0] = dp->buffer;
buf[1] = dp->buffer + 5*size/4;
buf[2] = dp->buffer + size;
if (priv->is_older)
{
int c;
c = stream_read_char(demux->stream); /* F */
if (c == -256)
return 0; /* EOF */
if (c != 'F')
{
mp_msg(MSGT_DEMUX, MSGL_V, "Bad frame at %d\n", (int)stream_tell(demux->stream)-1);
return 0;
}
stream_skip(demux->stream, 5); /* RAME\n */
stream_read(demux->stream, buf[0], size);
stream_read(demux->stream, buf[1], size/4);
stream_read(demux->stream, buf[2], size/4);
}
else
{
if ((err=y4m_read_frame(demux->stream, priv->si, &fi, buf)) != Y4M_OK) {
mp_msg(MSGT_DEMUX, MSGL_V, "error reading frame %s\n", y4m_strerr(err));
return 0;
}
}
/* This seems to be the right way to calculate the presentation time stamp */
dp->pts=(float)priv->framenum/((sh_video_t*)ds->sh)->fps;
priv->framenum++;
dp->pos=demux->filepos;
dp->flags=0;
ds_add_packet(ds, dp);
return 1;
}
/*
* Read the next element as a signed int.
*/
int64_t ebml_read_int(stream_t *s)
{
uint64_t value = 0;
uint64_t len;
int l;
len = ebml_read_length(s);
if (len == EBML_UINT_INVALID || len < 1 || len > 8)
return EBML_INT_INVALID;
len--;
l = stream_read_char(s);
if (l & 0x80)
value = -1;
value = (value << 8) | l;
while (len--)
value = (value << 8) | stream_read_char(s);
return (int64_t)value; // assume complement of 2
}
/*
* Read the next element as a signed int.
*/
int64_t ebml_read_int(stream_t *s, uint64_t *length)
{
int64_t value = 0;
uint64_t len;
int l;
len = ebml_read_length(s, &l);
if (len == EBML_UINT_INVALID || len < 1 || len > 8)
return EBML_INT_INVALID;
if (length)
*length = len + l;
len--;
l = stream_read_char(s);
if (l & 0x80)
value = -1;
value = (value << 8) | l;
while (len--)
value = (value << 8) | stream_read_char(s);
return value;
}
/*
* Read the next element as an unsigned int.
*/
uint64_t ebml_read_uint(stream_t *s)
{
uint64_t len, value = 0;
len = ebml_read_length(s);
if (len == EBML_UINT_INVALID || len < 1 || len > 8)
return EBML_UINT_INVALID;
while (len--)
value = (value << 8) | stream_read_char(s);
return value;
}
int mp4_read_descr_len(stream_t *s) {
uint8_t b;
uint8_t numBytes = 0;
uint32_t length = 0;
do {
b = stream_read_char(s);
numBytes++;
length = (length << 7) | (b & 0x7F);
} while ((b & 0x80) && numBytes < 4);
//printf("MP4 read desc len: %d\n", length);
return length;
}
static unsigned int get_adif_onebit(demuxer_t *demuxer)
{
unsigned int res;
if (bitno > 7)
{
input_byte = stream_read_char(demuxer->stream);
bitno = 0;
}
res = (input_byte & 0x80) ? 1 : 0;
input_byte <<= 1;
bitno++;
return res;
}
/// returns DEMUXER_TYPE_AAC if it finds 8 ADTS frames in 32768 bytes, 0 otherwise
static int demux_aac_probe(demuxer_t *demuxer)
{
int cnt = 0, c, len, srate, num;
loff_t init, probed;
aac_priv_t *priv;
if(! demux_aac_init(demuxer))
{
mp_msg(MSGT_DEMUX, MSGL_ERR, "COULDN'T INIT aac_demux, exit\n");
return 0;
}
priv = (aac_priv_t *) demuxer->priv;
init = probed = stream_tell(demuxer->stream);
while(probed-init <= 32768 && cnt < 8)
{
c = 0;
while(c != 0xFF)
{
c = stream_read_char(demuxer->stream);
if(c < 0)
goto fail;
}
priv->buf[0] = 0xFF;
if(stream_read(demuxer->stream, &(priv->buf[1]), 7) < 7)
goto fail;
len = aac_parse_frame(priv->buf, &srate, &num);
if(len > 0)
{
cnt++;
stream_skip(demuxer->stream, len - 8);
}
probed = stream_tell(demuxer->stream);
}
stream_seek(demuxer->stream, init);
if(cnt < 8)
goto fail;
mp_msg(MSGT_DEMUX, MSGL_V, "demux_aac_probe, INIT: %"PRIu64", PROBED: %"PRIu64", cnt: %d\n", init, probed, cnt);
return DEMUXER_TYPE_AAC;
fail:
mp_msg(MSGT_DEMUX, MSGL_V, "demux_aac_probe, failed to detect an AAC stream\n");
return 0;
}
/*
* Skip to (probable) next cluster (MATROSKA_ID_CLUSTER) element start position.
*/
int ebml_resync_cluster(struct mp_log *log, stream_t *s)
{
int64_t pos = stream_tell(s);
uint32_t last_4_bytes = 0;
mp_err(log, "Corrupt file detected. "
"Trying to resync starting from position %"PRId64"...\n", pos);
while (!s->eof) {
// Assumes MATROSKA_ID_CLUSTER is 4 bytes, with no 0 bytes.
if (last_4_bytes == MATROSKA_ID_CLUSTER) {
mp_err(log, "Cluster found at %"PRId64".\n", pos - 4);
stream_seek(s, pos - 4);
return 0;
}
last_4_bytes = (last_4_bytes << 8) | stream_read_char(s);
pos++;
}
return -1;
}
static unsigned int get_adif_bits(demuxer_t *demuxer, int numbits)
{
unsigned int res;
int i;
res = 0;
for (i = 0; i < numbits; i++)
{
res <<= 1;
if (bitno > 7)
{
input_byte = stream_read_char(demuxer->stream);
bitno = 0;
}
res |= (input_byte & 0x80) ? 1 : 0;
input_byte <<= 1;
bitno++;
}
return res;
}
void get_aac_duration(demuxer_t *demuxer, AVFormatContext *avfc){
uint8_t hdr[8];
int len,nf=0,srate,num,c,framesize,i;
loff_t init = stream_tell(demuxer->stream);
lavf_priv_t *priv= demuxer->priv;
AVCodecContext *codec;
stream_seek(demuxer->stream, demuxer->movi_start);
while(1){
c = 0;
while(c != 0xFF){
c = stream_read_char(demuxer->stream);
if(c < 0)
break;
}
hdr[0] = 0xFF;
if(stream_read(demuxer->stream, &(hdr[1]), 7) != 7)
break;
len = aac_parse_frame(hdr, &srate, &num);
if(len > 0){
nf++;
stream_skip(demuxer->stream, len - 8);
}else{
stream_skip(demuxer->stream, -6);
}
}
stream_seek(demuxer->stream, init);
for(i=0; i<avfc->nb_streams; i++){
codec= ((AVStream *)avfc->streams[i])->codec;
if((framesize = codec->frame_size)>0)
break;
}
//framesize = framesize>0?framesize:1024;
framesize = 1024;
if(nf && srate){
priv->avfc->duration = (double)((nf*framesize/srate)*AV_TIME_BASE);
}
}
static int pva_sync(demuxer_t * demuxer)
{
uint8_t buffer[5]={0,0,0,0,0};
int count;
pva_priv_t * priv = (pva_priv_t *) demuxer->priv;
/* This function is used to find the next nearest PVA packet start after a seek, since a PVA file
* is not indexed.
* The just_synced field is in the priv structure so that pva_get_payload knows pva_sync
* has already read (part of) the PVA header. This way we can avoid to seek back and (hopefully)
* be able to read from pipes and such.
*/
for(count=0 ; count<PVA_MAX_VIDEO_PACK_LEN && !demuxer->stream->eof && !priv->just_synced ; count++)
{
buffer[0]=buffer[1];
buffer[1]=buffer[2];
buffer[2]=buffer[3];
buffer[3]=buffer[4];
buffer[4]=stream_read_char(demuxer->stream);
/*
* Check for a PVA packet beginning sequence: we check both the "AV" word at the
* very beginning and the "0x55" reserved byte (which is unused and set to 0x55 by spec)
*/
if(buffer[0]=='A' && buffer[1] == 'V' && buffer[4] == 0x55) priv->just_synced=1;
//printf("demux_pva: pva_sync(): current offset= %ld\n",stream_tell(demuxer->stream));
}
if(priv->just_synced)
{
priv->synced_stream_id=buffer[2];
return 1;
}
else
{
return 0;
}
}
/* parse the data part of MP4 esds atoms */
int mp4_parse_esds(unsigned char *data, int datalen, esds_t *esds) {
/* create memory stream from data */
stream_t *s = new_memory_stream(data, datalen);
uint16_t len;
#ifdef MP4_DUMPATOM
{int i;
printf("ESDS Dump (%dbyte):\n", datalen);
for(i = 0; i < datalen; i++)
printf("%02X ", data[i]);
printf("\nESDS Dumped\n");}
#endif
memset(esds, 0, sizeof(esds_t));
esds->version = stream_read_char(s);
esds->flags = stream_read_int24(s);
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 version: %d flags: 0x%06X\n",
esds->version, esds->flags);
/* get and verify ES_DescrTag */
if (stream_read_char(s) == MP4ESDescrTag) {
/* read length */
len = mp4_read_descr_len(s);
esds->ESId = stream_read_word(s);
esds->streamPriority = stream_read_char(s);
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 ES Descriptor (%dBytes):\n"
" -> ESId: %d\n"
" -> streamPriority: %d\n",
len, esds->ESId, esds->streamPriority);
if (len < (5 + 15)) {
freereturn(s,1);
}
} else {
esds->ESId = stream_read_word(s);
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 ES Descriptor (%dBytes):\n"
" -> ESId: %d\n", 2, esds->ESId);
}
/* get and verify DecoderConfigDescrTab */
if (stream_read_char(s) != MP4DecConfigDescrTag) {
freereturn(s,1);
}
/* read length */
len = mp4_read_descr_len(s);
esds->objectTypeId = stream_read_char(s);
esds->streamType = stream_read_char(s);
esds->bufferSizeDB = stream_read_int24(s);
esds->maxBitrate = stream_read_dword(s);
esds->avgBitrate = stream_read_dword(s);
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 Decoder Config Descriptor (%dBytes):\n"
" -> objectTypeId: %d\n"
" -> streamType: 0x%02X\n"
" -> bufferSizeDB: 0x%06X\n"
" -> maxBitrate: %.3fkbit/s\n"
" -> avgBitrate: %.3fkbit/s\n",
len, esds->objectTypeId, esds->streamType,
esds->bufferSizeDB, esds->maxBitrate/1000.0,
esds->avgBitrate/1000.0);
esds->decoderConfigLen=0;
if (len < 15) {
freereturn(s,0);
}
/* get and verify DecSpecificInfoTag */
if (stream_read_char(s) != MP4DecSpecificDescrTag) {
freereturn(s,0);
}
/* read length */
esds->decoderConfigLen = len = mp4_read_descr_len(s);
esds->decoderConfig = malloc(esds->decoderConfigLen);
if (esds->decoderConfig) {
stream_read(s, esds->decoderConfig, esds->decoderConfigLen);
} else {
esds->decoderConfigLen = 0;
}
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 Decoder Specific Descriptor (%dBytes)\n", len);
/* get and verify SLConfigDescrTag */
if(stream_read_char(s) != MP4SLConfigDescrTag) {
freereturn(s,0);
}
/* Note: SLConfig is usually constant value 2, size 1Byte */
esds->SLConfigLen = len = mp4_read_descr_len(s);
esds->SLConfig = malloc(esds->SLConfigLen);
if (esds->SLConfig) {
stream_read(s, esds->SLConfig, esds->SLConfigLen);
} else {
esds->SLConfigLen = 0;
}
mp_msg(MSGT_DEMUX, MP4_DL,
"ESDS MPEG4 Sync Layer Config Descriptor (%dBytes)\n"
" -> predefined: %d\n", len, esds->SLConfig[0]);
/* will skip the remainder of the atom */
freereturn(s,0);
}
static int demux_aac_fill_buffer(demuxer_t *demuxer, demux_stream_t *ds)
{
aac_priv_t *priv = (aac_priv_t *) demuxer->priv;
demux_packet_t *dp;
int c1, c2, len, srate, num;
float tm = 0;
if(demuxer->stream->eof || (demuxer->movi_end && stream_tell(demuxer->stream) >= demuxer->movi_end))
return 0;
while(! demuxer->stream->eof)
{
c1 = c2 = 0;
while(c1 != 0xFF)
{
c1 = stream_read_char(demuxer->stream);
if(c1 < 0)
return 0;
}
c2 = stream_read_char(demuxer->stream);
if(c2 < 0)
return 0;
if((c2 & 0xF6) != 0xF0)
continue;
priv->buf[0] = (unsigned char) c1;
priv->buf[1] = (unsigned char) c2;
if(stream_read(demuxer->stream, &(priv->buf[2]), 6) < 6)
return 0;
len = aac_parse_frame(priv->buf, &srate, &num);
if(len > 0)
{
dp = new_demux_packet(len);
if(! dp)
{
mp_msg(MSGT_DEMUX, MSGL_ERR, "fill_buffer, NEW_ADD_PACKET(%d)FAILED\n", len);
return 0;
}
memcpy(dp->buffer, priv->buf, 8);
stream_read(demuxer->stream, &(dp->buffer[8]), len-8);
if(srate)
tm = (float) (num * 1024.0/srate);
priv->last_pts += tm;
dp->pts = priv->last_pts;
//fprintf(stderr, "\nPTS: %.3f\n", dp->pts);
ds_add_packet(demuxer->audio, dp);
priv->size += len;
priv->time += tm;
priv->bitrate = (int) (priv->size / priv->time);
demuxer->filepos = stream_tell(demuxer->stream);
return len;
}
else
stream_skip(demuxer->stream, -6);
}
return 0;
}
// return value:
// 0 = EOF or no stream found
// 1 = successfully read a packet
static int demux_vivo_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
demux_stream_t *ds=NULL;
int c;
int len=0;
int seq;
int prefix=0;
demux->filepos=stream_tell(demux->stream);
c=stream_read_char(demux->stream);
if (c == -256) /* EOF */
return 0;
// printf("c=%x,%02X\n",c,c&0xf0);
if (c == 0x82)
{
/* ok, this works, but pts calculating from header is required! */
#warning "Calculate PTS from picture header!"
prefix = 1;
c = stream_read_char(demux->stream);
mp_msg(MSGT_DEMUX, MSGL_V, "packet 0x82(pos=%u) chunk=%x\n",
(int)stream_tell(demux->stream), c);
}
switch(c&0xF0){
case 0x00: // header - skip it!
{
len=stream_read_char(demux->stream);
if(len>=0x80) len=0x80*(len-0x80)+stream_read_char(demux->stream);
mp_msg(MSGT_DEMUX, MSGL_V, "vivo extra header: %d bytes\n",len);
#ifdef TEXTPARSE_ALL
{
int pos;
/* also try to parse all headers */
pos = stream_tell(demux->stream);
vivo_parse_text_header(demux, len);
stream_seek(demux->stream, pos);
}
#endif
break;
}
case 0x10: // video packet
if (prefix == 1)
len = stream_read_char(demux->stream);
else
len=128;
ds=demux->video;
break;
case 0x20: // video packet
len=stream_read_char(demux->stream);
ds=demux->video;
break;
case 0x30: // audio packet
if (prefix == 1)
len = stream_read_char(demux->stream);
else
len=40; /* 40kbps */
ds=demux->audio;
audio_pos+=len;
break;
case 0x40: // audio packet
if (prefix == 1)
len = stream_read_char(demux->stream);
else
len=24; /* 24kbps */
ds=demux->audio;
audio_pos+=len;
break;
default:
mp_msg(MSGT_DEMUX,MSGL_WARN,"VIVO - unknown ID found: %02X at pos %"PRIu64" contact author!\n",
c, (int64_t)stream_tell(demux->stream));
return 0;
}
// printf("chunk=%x, len=%d\n", c, len);
if(!ds || ds->id<-1){
if(len) stream_skip(demux->stream,len);
return 1;
}
seq=c&0x0F;
if(ds->asf_packet){
if(ds->asf_seq!=seq){
// closed segment, finalize packet:
ds_add_packet(ds,ds->asf_packet);
ds->asf_packet=NULL;
// printf("packet!\n");
} else {
// append data to it!
demux_packet_t* dp=ds->asf_packet;
if(dp->len + len + FF_INPUT_BUFFER_PADDING_SIZE < 0)
return 0;
dp->buffer=realloc(dp->buffer,dp->len+len+FF_INPUT_BUFFER_PADDING_SIZE);
memset(dp->buffer+dp->len+len, 0, FF_INPUT_BUFFER_PADDING_SIZE);
//memcpy(dp->buffer+dp->len,data,len);
stream_read(demux->stream,dp->buffer+dp->len,len);
mp_dbg(MSGT_DEMUX,MSGL_DBG4,"data appended! %d+%d\n",dp->len,len);
dp->len+=len;
// we are ready now.
if((c&0xF0)==0x20) --ds->asf_seq; // hack!
return 1;
}
}
// create new packet:
{ demux_packet_t* dp;
dp=new_demux_packet(len);
//memcpy(dp->buffer,data,len);
stream_read(demux->stream,dp->buffer,len);
dp->pts=audio_rate?((float)audio_pos/(float)audio_rate):0;
// dp->flags=keyframe;
// if(ds==demux->video) printf("ASF time: %8d dur: %5d \n",time,dur);
dp->pos=demux->filepos;
ds->asf_packet=dp;
ds->asf_seq=seq;
// we are ready now.
return 1;
}
}
static int vivo_check_file(demuxer_t* demuxer){
int i=0;
int len;
int c;
unsigned char buf[2048+256];
vivo_priv_t* priv;
int orig_pos = stream_tell(demuxer->stream);
mp_msg(MSGT_DEMUX,MSGL_V,"Checking for VIVO\n");
c=stream_read_char(demuxer->stream);
if(c==-256) return 0;
len=0;
while((c=stream_read_char(demuxer->stream))>=0x80){
len+=0x80*(c-0x80);
if(len>1024) return 0;
}
len+=c;
mp_msg(MSGT_DEMUX,MSGL_V,"header block 1 size: %d\n",len);
//stream_skip(demuxer->stream,len);
priv=malloc(sizeof(vivo_priv_t));
memset(priv,0,sizeof(vivo_priv_t));
demuxer->priv=priv;
#if 0
vivo_parse_text_header(demuxer, len);
if (priv->supported == 0)
return 0;
#else
/* this is enought for check (for now) */
stream_read(demuxer->stream,buf,len);
buf[len]=0;
// printf("VIVO header: '%s'\n",buf);
// parse header:
i=0;
while(i<len && buf[i]==0x0D && buf[i+1]==0x0A) i+=2; // skip empty lines
if(strncmp(buf+i,"Version:Vivo/",13)) return 0; // bad version/type!
#endif
#if 0
c=stream_read_char(demuxer->stream);
if(c) return 0;
len2=0;
while((c=stream_read_char(demuxer->stream))>=0x80){
len2+=0x80*(c-0x80);
if(len+len2>2048) return 0;
}
len2+=c;
mp_msg(MSGT_DEMUX,MSGL_V,"header block 2 size: %d\n",len2);
stream_skip(demuxer->stream,len2);
// stream_read(demuxer->stream,buf+len,len2);
#endif
// c=stream_read_char(demuxer->stream);
// printf("first packet: %02X\n",c);
stream_seek(demuxer->stream, orig_pos);
return DEMUXER_TYPE_VIVO;
}
static demuxer_t* demux_open_smjpeg(demuxer_t* demuxer){
sh_video_t* sh_video;
sh_audio_t* sh_audio;
unsigned int htype = 0, hleng;
int i = 0;
/* file header */
stream_skip(demuxer->stream, 8); /* \x00\x0aSMJPEG */
stream_skip(demuxer->stream, 4);
mp_msg(MSGT_DEMUX, MSGL_INFO, "This clip is %d seconds\n",
stream_read_dword(demuxer->stream));
/* stream header */
while (i < 3)
{
i++;
htype = stream_read_dword_le(demuxer->stream);
if (htype == mmioFOURCC('H','E','N','D'))
break;
hleng = (stream_read_word(demuxer->stream)<<16)|stream_read_word(demuxer->stream);
switch(htype)
{
case mmioFOURCC('_','V','I','D'):
sh_video = new_sh_video(demuxer, 0);
demuxer->video->sh = sh_video;
sh_video->ds = demuxer->video;
sh_video->bih = malloc(sizeof(BITMAPINFOHEADER));
memset(sh_video->bih, 0, sizeof(BITMAPINFOHEADER));
stream_skip(demuxer->stream, 4); /* number of frames */
// sh_video->fps = 24;
// sh_video->frametime = 1.0f/sh_video->fps;
sh_video->disp_w = stream_read_word(demuxer->stream);
sh_video->disp_h = stream_read_word(demuxer->stream);
sh_video->format = stream_read_dword_le(demuxer->stream);
/* these are false values */
sh_video->bih->biSize = 40;
sh_video->bih->biWidth = sh_video->disp_w;
sh_video->bih->biHeight = sh_video->disp_h;
sh_video->bih->biPlanes = 3;
sh_video->bih->biBitCount = 12;
sh_video->bih->biCompression = sh_video->format;
sh_video->bih->biSizeImage = sh_video->disp_w*sh_video->disp_h;
break;
case mmioFOURCC('_','S','N','D'):
sh_audio = new_sh_audio(demuxer, 0);
demuxer->audio->sh = sh_audio;
sh_audio->ds = demuxer->audio;
sh_audio->wf = malloc(sizeof(WAVEFORMATEX));
memset(sh_audio->wf, 0, sizeof(WAVEFORMATEX));
sh_audio->samplerate = stream_read_word(demuxer->stream);
sh_audio->wf->wBitsPerSample = stream_read_char(demuxer->stream);
sh_audio->channels = stream_read_char(demuxer->stream);
sh_audio->format = stream_read_dword_le(demuxer->stream);
sh_audio->wf->wFormatTag = sh_audio->format;
sh_audio->wf->nChannels = sh_audio->channels;
sh_audio->wf->nSamplesPerSec = sh_audio->samplerate;
sh_audio->wf->nAvgBytesPerSec = sh_audio->wf->nChannels*
sh_audio->wf->wBitsPerSample*sh_audio->wf->nSamplesPerSec/8;
sh_audio->wf->nBlockAlign = sh_audio->channels *2;
sh_audio->wf->cbSize = 0;
break;
case mmioFOURCC('_','T','X','T'):
stream_skip(demuxer->stream, stream_read_dword(demuxer->stream));
break;
}
}
demuxer->seekable = 0;
return demuxer;
}
static int pva_get_payload(demuxer_t *d, pva_payload_t *payload)
{
uint8_t flags,pes_head_len;
uint16_t pack_size;
off_t pva_payload_start;
unsigned char buffer[256];
pva_priv_t * priv;
if(d==NULL)
{
mp_msg(MSGT_DEMUX,MSGL_ERR,"demux_pva: pva_get_payload got passed a NULL pointer!\n");
return 0;
}
priv = (pva_priv_t *)d->priv;
d->filepos=stream_tell(d->stream);
if(d->stream->eof)
{
mp_msg(MSGT_DEMUX,MSGL_V,"demux_pva: pva_get_payload() detected stream->eof!!!\n");
return 0;
}
//printf("priv->just_synced %s\n",priv->just_synced?"SET":"UNSET");
if(priv->prebytes_delivered)
/* The previous call to this fn has delivered the preBytes. Then we are already inside
* the payload. Let's just deliver the video along with its right PTS, the one we stored
* in the priv structure and was in the PVA header before the PreBytes.
*/
{
//printf("prebytes_delivered=1. Resetting.\n");
payload->size = priv->video_size_after_prebytes;
payload->pts = priv->video_pts_after_prebytes;
payload->is_packet_start = 1;
payload->offset = stream_tell(d->stream);
payload->type = VIDEOSTREAM;
priv->prebytes_delivered = 0;
return 1;
}
if(!priv->just_synced)
{
if(stream_read_word(d->stream) != (('A'<<8)|'V'))
{
mp_msg(MSGT_DEMUX,MSGL_V,"demux_pva: pva_get_payload() missed a SyncWord at %"PRId64"!! Trying to sync...\n",(int64_t)stream_tell(d->stream));
if(!pva_sync(d))
{
if (!d->stream->eof)
{
mp_msg(MSGT_DEMUX,MSGL_ERR,"demux_pva: couldn't sync! (broken file?)");
}
return 0;
}
}
}
if(priv->just_synced)
{
payload->type=priv->synced_stream_id;
priv->just_synced=0;
}
else
{
payload->type=stream_read_char(d->stream);
stream_skip(d->stream,2); //counter and reserved
}
flags=stream_read_char(d->stream);
payload->is_packet_start=flags & 0x10;
pack_size=stream_read_word(d->stream);
mp_msg(MSGT_DEMUX,MSGL_DBG2,"demux_pva::pva_get_payload(): pack_size=%u field read at offset %"PRIu64"\n",pack_size,(int64_t)stream_tell(d->stream)-2);
pva_payload_start=stream_tell(d->stream);
/*
* The code in the #ifdef directive below is a hack needed to get badly formatted PVA files
* such as the ones written by MultiDec played back correctly.
* Basically, it works like this: if the PVA packet does not signal a PES header, but the
* payload looks like one, let's assume it IS one. It has worked for me up to now.
* It can be disabled since it's quite an ugly hack and could potentially break things up
* if the PVA audio payload happens to start with 0x000001 even without being a non signalled
* PES header start.
* Though it's quite unlikely, it potentially could (AFAIK).
*/
#ifdef DEMUX_PVA_MULTIDEC_HACK
if(payload->type==MAINAUDIOSTREAM)
{
stream_read(d->stream,buffer,3);
if(buffer[0]==0x00 && buffer[1]==0x00 && buffer[2]==0x01 && !payload->is_packet_start)
{
mp_msg(MSGT_DEMUX,MSGL_V,"demux_pva: suspecting non signaled audio PES packet start. Maybe file by MultiDec?\n");
payload->is_packet_start=1;
}
stream_seek(d->stream,stream_tell(d->stream)-3);
}
#endif
if(!payload->is_packet_start)
{
payload->offset=stream_tell(d->stream);
payload->size=pack_size;
}
else
{ //here comes the good part...
switch(payload->type)
{
case VIDEOSTREAM:
payload->pts=(float)(stream_read_dword(d->stream))/90000;
//printf("Video PTS: %f\n",payload->pts);
if((flags&0x03)
&& !priv->prebytes_delivered
)
{
//printf("Delivering prebytes. Setting prebytes_delivered.");
payload->offset=stream_tell(d->stream);
payload->size = flags & 0x03;
priv->video_pts_after_prebytes = payload->pts;
priv->video_size_after_prebytes = pack_size - 4 - (flags & 0x03);
payload->pts=priv->last_video_pts;
payload->is_packet_start=0;
priv->prebytes_delivered=1;
return 1;
}
//now we are at real beginning of payload.
payload->offset=stream_tell(d->stream);
//size is pack_size minus PTS size minus PreBytes size.
payload->size=pack_size - 4 - (flags & 0x03);
break;
case MAINAUDIOSTREAM:
stream_skip(d->stream,3); //FIXME properly parse PES header.
//printf("StreamID in audio PES header: 0x%2X\n",stream_read_char(d->stream));
stream_skip(d->stream,4);
buffer[255]=stream_read_char(d->stream);
pes_head_len=stream_read_char(d->stream);
stream_read(d->stream,buffer,pes_head_len);
if(!(buffer[255]&0x80)) //PES header does not contain PTS.
{
mp_msg(MSGT_DEMUX,MSGL_V,"Audio PES packet does not contain PTS. (pes_head_len=%d)\n",pes_head_len);
payload->pts=priv->last_audio_pts;
break;
}
else //PES header DOES contain PTS
{
if((buffer[0] & 0xf0)!=0x20) // PTS badly formatted
{
mp_msg(MSGT_DEMUX,MSGL_V,"demux_pva: expected audio PTS but badly formatted... (read 0x%02X). Falling back to previous PTS (hack).\n",buffer[0]);
payload->pts=priv->last_audio_pts;
// return 0;
}
else
{
uint64_t temp_pts;
temp_pts=0LL;
temp_pts|=((uint64_t)(buffer[0] & 0x0e) << 29);
temp_pts|=buffer[1]<<22;
temp_pts|=(buffer[2] & 0xfe) << 14;
temp_pts|=buffer[3]<<7;
temp_pts|=(buffer[4] & 0xfe) >> 1;
/*
* PTS parsing is hopefully finished.
*/
payload->pts=(float)temp_pts/90000;
}
}
payload->offset=stream_tell(d->stream);
payload->size=pack_size-stream_tell(d->stream)+pva_payload_start;
break;
}
}
return 1;
}
void read_avi_header(demuxer_t *demuxer,int index_mode){
sh_audio_t *sh_audio=NULL;
sh_video_t *sh_video=NULL;
int stream_id=-1;
int idxfix_videostream=0;
int idxfix_divx=0;
avi_priv_t* priv=demuxer->priv;
off_t list_end=0;
//---- AVI header:
priv->idx_size=0;
priv->audio_streams=0;
while(1){
int id=stream_read_dword_le(demuxer->stream);
unsigned chunksize,size2;
static int last_fccType=0;
static int last_fccHandler=0;
char* hdr=NULL;
//
if(stream_eof(demuxer->stream)) break;
// Imply -forceidx if -saveidx is specified
if (index_file_save)
index_mode = 2;
//
if(id==mmioFOURCC('L','I','S','T')){
unsigned len=stream_read_dword_le(demuxer->stream); // list size
id=stream_read_dword_le(demuxer->stream); // list type
mp_msg(MSGT_HEADER,MSGL_DBG2,"LIST %.4s len=%u\n",(char *) &id,len);
if(len >= 4) {
len -= 4;
list_end=stream_tell(demuxer->stream)+((len+1)&(~1));
} else {
mp_msg(MSGT_HEADER,MSGL_WARN,MSGTR_MPDEMUX_AVIHDR_EmptyList);
list_end = 0;
}
mp_msg(MSGT_HEADER,MSGL_V,"list_end=0x%X\n",(int)list_end);
if(id==listtypeAVIMOVIE){
// found MOVI header
if(!demuxer->movi_start) demuxer->movi_start=stream_tell(demuxer->stream);
demuxer->movi_end=stream_tell(demuxer->stream)+len;
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundMovieAt,(int)demuxer->movi_start,(int)demuxer->movi_end);
if(demuxer->stream->end_pos>demuxer->movi_end) demuxer->movi_end=demuxer->stream->end_pos;
if(index_mode==-2 || index_mode==2 || index_mode==0)
break; // reading from non-seekable source (stdin) or forced index or no index forced
if(list_end>0) stream_seek(demuxer->stream,list_end); // skip movi
list_end=0;
}
continue;
}
size2=stream_read_dword_le(demuxer->stream);
mp_msg(MSGT_HEADER,MSGL_DBG2,"CHUNK %.4s len=%u\n",(char *) &id,size2);
chunksize=(size2+1)&(~1);
switch(id){
// Indicates where the subject of the file is archived
case mmioFOURCC('I','A','R','L'): hdr="Archival Location";break;
// Lists the artist of the original subject of the file;
// for example, "Michaelangelo."
case mmioFOURCC('I','A','R','T'): hdr="Artist";break;
// Lists the name of the person or organization that commissioned
// the subject of the file; for example "Pope Julian II."
case mmioFOURCC('I','C','M','S'): hdr="Commissioned";break;
// Provides general comments about the file or the subject
// of the file. If the comment is several sentences long, end each
// sentence with a period. Do not include new-line characters.
case mmioFOURCC('I','C','M','T'): hdr="Comments";break;
// Records the copyright information for the file; for example,
// "Copyright Encyclopedia International 1991." If there are multiple
// copyrights, separate them by semicolon followed by a space.
case mmioFOURCC('I','C','O','P'): hdr="Copyright";break;
// Describes whether an image has been cropped and, if so, how it
// was cropped; for example, "lower-right corner."
case mmioFOURCC('I','C','R','D'): hdr="Creation Date";break;
// Describes whether an image has been cropped and, if so, how it
// was cropped; for example, "lower-right corner."
case mmioFOURCC('I','C','R','P'): hdr="Cropped";break;
// Specifies the size of the original subject of the file; for
// example, "8.5 in h, 11 in w."
case mmioFOURCC('I','D','I','M'): hdr="Dimensions";break;
// Stores dots per inch setting of the digitizer used to
// produce the file, such as "300."
case mmioFOURCC('I','D','P','I'): hdr="Dots Per Inch";break;
// Stores the of the engineer who worked on the file. If there are
// multiple engineers, separate the names by a semicolon and a blank;
// for example, "Smith, John; Adams, Joe."
case mmioFOURCC('I','E','N','G'): hdr="Engineer";break;
// Describes the original work, such as "landscape,", "portrait,"
// "still liefe," etc.
case mmioFOURCC('I','G','N','R'): hdr="Genre";break;
// Provides a list of keywords that refer to the file or subject of the
// file. Separate multiple keywords with a semicolon and a blank;
// for example, "Seattle, aerial view; scenery."
case mmioFOURCC('I','K','E','Y'): hdr="Keywords";break;
// ILGT - Describes the changes in the lightness settings on the digitizer
// required to produce the file. Note that the format of this information
// depends on the hardware used.
case mmioFOURCC('I','L','G','T'): hdr="Lightness";break;
// IMED - Decribes the original subject of the file, such as
// "computer image," "drawing," "lithograph," and so on.
case mmioFOURCC('I','M','E','D'): hdr="Medium";break;
// INAM - Stores the title of the subject of the file, such as
// "Seattle from Above."
case mmioFOURCC('I','N','A','M'): hdr="Title";break;
// IPLT - Specifies the number of colors requested when digitizing
// an image, such as "256."
case mmioFOURCC('I','P','L','T'): hdr="Palette Setting";break;
// IPRD - Specifies the name of title the file was originally intended
// for, such as "Encyclopedia of Pacific Northwest Geography."
case mmioFOURCC('I','P','R','D'): hdr="Product";break;
// ISBJ - Decsribes the contents of the file, such as
// "Aerial view of Seattle."
case mmioFOURCC('I','S','B','J'): hdr="Subject";break;
// ISFT - Identifies the name of the software packages used to create the
// file, such as "Microsoft WaveEdit"
case mmioFOURCC('I','S','F','T'): hdr="Software";break;
// ISHP - Identifies the change in sharpness for the digitizer
// required to produce the file (the format depends on the hardware used).
case mmioFOURCC('I','S','H','P'): hdr="Sharpness";break;
// ISRC - Identifies the name of the person or organization who
// suplied the original subject of the file; for example, "Try Research."
case mmioFOURCC('I','S','R','C'): hdr="Source";break;
// ISRF - Identifies the original form of the material that was digitized,
// such as "slide," "paper," "map," and so on. This is not necessarily
// the same as IMED
case mmioFOURCC('I','S','R','F'): hdr="Source Form";break;
// ITCH - Identifies the technician who digitized the subject file;
// for example, "Smith, John."
case mmioFOURCC('I','T','C','H'): hdr="Technician";break;
case mmioFOURCC('I','S','M','P'): hdr="Time Code";break;
case mmioFOURCC('I','D','I','T'): hdr="Digitization Time";break;
case ckidAVIMAINHDR: // read 'avih'
stream_read(demuxer->stream,(char*) &avih,FFMIN(size2,sizeof(avih)));
le2me_MainAVIHeader(&avih); // swap to machine endian
chunksize-=FFMIN(size2,sizeof(avih));
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_avih(&avih,MSGL_V); // else print_avih_flags(&avih,MSGL_V);
break;
case ckidSTREAMHEADER: { // read 'strh'
AVIStreamHeader h;
stream_read(demuxer->stream,(char*) &h,FFMIN(size2,sizeof(h)));
le2me_AVIStreamHeader(&h); // swap to machine endian
chunksize-=FFMIN(size2,sizeof(h));
++stream_id;
if(h.fccType==streamtypeVIDEO){
sh_video=new_sh_video(demuxer,stream_id);
mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_VideoID, "aviheader", stream_id);
memcpy(&sh_video->video,&h,sizeof(h));
sh_video->stream_delay = (float)sh_video->video.dwStart * sh_video->video.dwScale/sh_video->video.dwRate;
} else
if(h.fccType==streamtypeAUDIO){
sh_audio=new_sh_audio(demuxer,stream_id);
mp_msg(MSGT_DEMUX, MSGL_INFO, MSGTR_AudioID, "aviheader", stream_id);
memcpy(&sh_audio->audio,&h,sizeof(h));
sh_audio->stream_delay = (float)sh_audio->audio.dwStart * sh_audio->audio.dwScale/sh_audio->audio.dwRate;
}
last_fccType=h.fccType;
last_fccHandler=h.fccHandler;
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_strh(&h,MSGL_V);
break; }
case mmioFOURCC('i', 'n', 'd', 'x'): {
uint32_t i;
avisuperindex_chunk *s;
if(!index_mode) break;
if(chunksize<=24){
break;
}
priv->suidx_size++;
priv->suidx = realloc_struct(priv->suidx, priv->suidx_size, sizeof (avisuperindex_chunk));
s = &priv->suidx[priv->suidx_size-1];
chunksize-=24;
memcpy(s->fcc, "indx", 4);
s->dwSize = size2;
s->wLongsPerEntry = stream_read_word_le(demuxer->stream);
s->bIndexSubType = stream_read_char(demuxer->stream);
s->bIndexType = stream_read_char(demuxer->stream);
s->nEntriesInUse = stream_read_dword_le(demuxer->stream);
*(uint32_t *)s->dwChunkId = stream_read_dword_le(demuxer->stream);
stream_read(demuxer->stream, (char *)s->dwReserved, 3*4);
memset(s->dwReserved, 0, 3*4);
print_avisuperindex_chunk(s,MSGL_V);
// Check and fix this useless crap
if(s->wLongsPerEntry != sizeof (avisuperindex_entry)/4) {
mp_msg (MSGT_HEADER, MSGL_WARN, "Broken super index chunk size: %u\n",s->wLongsPerEntry);
s->wLongsPerEntry = sizeof(avisuperindex_entry)/4;
}
if( ((chunksize/4)/s->wLongsPerEntry) < s->nEntriesInUse){
mp_msg (MSGT_HEADER, MSGL_WARN, "Broken super index chunk\n");
s->nEntriesInUse = (chunksize/4)/s->wLongsPerEntry;
}
s->aIndex = calloc(s->nEntriesInUse, sizeof (avisuperindex_entry));
s->stdidx = calloc(s->nEntriesInUse, sizeof (avistdindex_chunk));
// now the real index of indices
for (i=0; i<s->nEntriesInUse; i++) {
chunksize-=16;
s->aIndex[i].qwOffset = stream_read_qword_le(demuxer->stream);
s->aIndex[i].dwSize = stream_read_dword_le(demuxer->stream);
s->aIndex[i].dwDuration = stream_read_dword_le(demuxer->stream);
mp_msg (MSGT_HEADER, MSGL_V, "ODML (%.4s): [%d] 0x%016"PRIx64" 0x%04x %u\n",
(s->dwChunkId), i,
(uint64_t)s->aIndex[i].qwOffset, s->aIndex[i].dwSize, s->aIndex[i].dwDuration);
}
break; }
case ckidSTREAMFORMAT: { // read 'strf'
if(last_fccType==streamtypeVIDEO){
sh_video->bih=calloc(FFMAX(chunksize, sizeof(BITMAPINFOHEADER)), 1);
// sh_video->bih=malloc(chunksize); memset(sh_video->bih,0,chunksize);
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundBitmapInfoHeader,chunksize,sizeof(BITMAPINFOHEADER));
stream_read(demuxer->stream,(char*) sh_video->bih,chunksize);
le2me_BITMAPINFOHEADER(sh_video->bih); // swap to machine endian
if (sh_video->bih->biSize > chunksize && sh_video->bih->biSize > sizeof(BITMAPINFOHEADER))
sh_video->bih->biSize = chunksize;
// fixup MS-RLE header (seems to be broken for <256 color files)
if(sh_video->bih->biCompression<=1 && sh_video->bih->biSize==40)
sh_video->bih->biSize=chunksize;
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_video_header(sh_video->bih,MSGL_V);
chunksize=0;
sh_video->fps=(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
sh_video->frametime=(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
sh_video->format = sh_video->bih->biCompression;
// if(demuxer->video->id==-1) demuxer->video->id=stream_id;
// IdxFix:
idxfix_videostream=stream_id;
switch(sh_video->bih->biCompression){
case mmioFOURCC('M', 'P', 'G', '4'):
case mmioFOURCC('m', 'p', 'g', '4'):
case mmioFOURCC('D', 'I', 'V', '1'):
idxfix_divx=3; // set index recovery mpeg4 flavour: msmpeg4v1
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForMPG4V1);
break;
case mmioFOURCC('D', 'I', 'V', '3'):
case mmioFOURCC('d', 'i', 'v', '3'):
case mmioFOURCC('D', 'I', 'V', '4'):
case mmioFOURCC('d', 'i', 'v', '4'):
case mmioFOURCC('D', 'I', 'V', '5'):
case mmioFOURCC('d', 'i', 'v', '5'):
case mmioFOURCC('D', 'I', 'V', '6'):
case mmioFOURCC('d', 'i', 'v', '6'):
case mmioFOURCC('M', 'P', '4', '3'):
case mmioFOURCC('m', 'p', '4', '3'):
case mmioFOURCC('M', 'P', '4', '2'):
case mmioFOURCC('m', 'p', '4', '2'):
case mmioFOURCC('D', 'I', 'V', '2'):
case mmioFOURCC('A', 'P', '4', '1'):
idxfix_divx=1; // set index recovery mpeg4 flavour: msmpeg4v3
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForDIVX3);
break;
case mmioFOURCC('D', 'I', 'V', 'X'):
case mmioFOURCC('d', 'i', 'v', 'x'):
case mmioFOURCC('D', 'X', '5', '0'):
case mmioFOURCC('X', 'V', 'I', 'D'):
case mmioFOURCC('x', 'v', 'i', 'd'):
case mmioFOURCC('F', 'M', 'P', '4'):
case mmioFOURCC('f', 'm', 'p', '4'):
idxfix_divx=2; // set index recovery mpeg4 flavour: generic mpeg4
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_RegeneratingKeyfTableForMPEG4);
break;
}
} else
if(last_fccType==streamtypeAUDIO){
unsigned wf_size = chunksize<sizeof(WAVEFORMATEX)?sizeof(WAVEFORMATEX):chunksize;
sh_audio->wf=calloc(wf_size,1);
// sh_audio->wf=malloc(chunksize); memset(sh_audio->wf,0,chunksize);
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundWaveFmt,chunksize,sizeof(WAVEFORMATEX));
stream_read(demuxer->stream,(char*) sh_audio->wf,chunksize);
le2me_WAVEFORMATEX(sh_audio->wf);
if (sh_audio->wf->cbSize != 0 &&
wf_size < sizeof(WAVEFORMATEX)+sh_audio->wf->cbSize) {
sh_audio->wf=realloc(sh_audio->wf, sizeof(WAVEFORMATEX)+sh_audio->wf->cbSize);
}
sh_audio->format=sh_audio->wf->wFormatTag;
if (sh_audio->format == 1 &&
last_fccHandler == mmioFOURCC('A', 'x', 'a', 'n'))
sh_audio->format = last_fccHandler;
sh_audio->i_bps=sh_audio->wf->nAvgBytesPerSec;
chunksize=0;
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_wave_header(sh_audio->wf,MSGL_V);
++priv->audio_streams;
// if(demuxer->audio->id==-1) demuxer->audio->id=stream_id;
}
break;
}
case mmioFOURCC('v', 'p', 'r', 'p'): {
VideoPropHeader *vprp = malloc(chunksize);
unsigned int i;
stream_read(demuxer->stream, (void*)vprp, chunksize);
le2me_VideoPropHeader(vprp);
chunksize -= sizeof(*vprp)-sizeof(vprp->FieldInfo);
chunksize /= sizeof(VIDEO_FIELD_DESC);
if (vprp->nbFieldPerFrame > chunksize) {
vprp->nbFieldPerFrame = chunksize;
}
chunksize = 0;
for (i=0; i<vprp->nbFieldPerFrame; i++) {
le2me_VIDEO_FIELD_DESC(&vprp->FieldInfo[i]);
}
if (sh_video) {
sh_video->aspect = GET_AVI_ASPECT(vprp->dwFrameAspectRatio);
}
if( mp_msg_test(MSGT_HEADER,MSGL_V) ) print_vprp(vprp,MSGL_V);
free(vprp);
break;
}
case mmioFOURCC('d', 'm', 'l', 'h'): {
// dmlh 00 00 00 04 frms
unsigned int total_frames = stream_read_dword_le(demuxer->stream);
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_FoundAVIV2Header, chunksize, total_frames);
stream_skip(demuxer->stream, chunksize-4);
chunksize = 0;
}
break;
case ckidAVINEWINDEX:
if(demuxer->movi_end>stream_tell(demuxer->stream))
demuxer->movi_end=stream_tell(demuxer->stream); // fixup movi-end
if(index_mode && !priv->isodml){
int i;
priv->idx_size=size2>>4;
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_ReadingIndexBlockChunksForFrames,
priv->idx_size,avih.dwTotalFrames, (int64_t)stream_tell(demuxer->stream));
priv->idx=malloc(priv->idx_size<<4);
// printf("\nindex to %p !!!!! (priv=%p)\n",priv->idx,priv);
stream_read(demuxer->stream,(char*)priv->idx,priv->idx_size<<4);
for (i = 0; i < priv->idx_size; i++) { // swap index to machine endian
AVIINDEXENTRY *entry=(AVIINDEXENTRY*)priv->idx + i;
le2me_AVIINDEXENTRY(entry);
/*
* We (ab)use the upper word for bits 32-47 of the offset, so
* we'll clear them here.
* FIXME: AFAIK no codec uses them, but if one does it will break
*/
entry->dwFlags&=0xffff;
}
chunksize-=priv->idx_size<<4;
if( mp_msg_test(MSGT_HEADER,MSGL_DBG2) ) print_index(priv->idx,priv->idx_size,MSGL_DBG2);
}
break;
/* added May 2002 */
case mmioFOURCC('R','I','F','F'): {
char riff_type[4];
mp_msg(MSGT_HEADER, MSGL_V, MSGTR_MPDEMUX_AVIHDR_AdditionalRIFFHdr);
stream_read(demuxer->stream, riff_type, sizeof riff_type);
if (strncmp(riff_type, "AVIX", sizeof riff_type))
mp_msg(MSGT_HEADER, MSGL_WARN, MSGTR_MPDEMUX_AVIHDR_WarnNotExtendedAVIHdr);
else {
/*
* We got an extended AVI header, so we need to switch to
* ODML to get seeking to work, provided we got indx chunks
* in the header (suidx_size > 0).
*/
if (priv->suidx_size > 0)
priv->isodml = 1;
}
chunksize = 0;
list_end = 0; /* a new list will follow */
break; }
case ckidAVIPADDING:
stream_skip(demuxer->stream, chunksize);
chunksize = 0;
break;
}
if(hdr){
mp_msg(MSGT_HEADER,MSGL_V,"hdr=%s size=%u\n",hdr,size2);
if(size2==3)
chunksize=1; // empty
else {
char buf[256];
int len=(size2<250)?size2:250;
stream_read(demuxer->stream,buf,len);
chunksize-=len;
buf[len]=0;
mp_msg(MSGT_HEADER,MSGL_V,"%-10s: %s\n",hdr,buf);
demux_info_add(demuxer, hdr, buf);
}
}
mp_msg(MSGT_HEADER,MSGL_DBG2,"list_end=0x%"PRIX64" pos=0x%"PRIX64" chunksize=0x%"PRIX64" next=0x%"PRIX64"\n",
(int64_t)list_end, (int64_t)stream_tell(demuxer->stream),
(int64_t)chunksize, (int64_t)chunksize+(int64_t)stream_tell(demuxer->stream));
if(list_end>0 &&
chunksize+stream_tell(demuxer->stream) == list_end) list_end=0;
if(list_end>0 && chunksize+stream_tell(demuxer->stream)>list_end){
mp_msg(MSGT_HEADER,MSGL_V,MSGTR_MPDEMUX_AVIHDR_BrokenChunk,chunksize,(char *) &id);
stream_seek(demuxer->stream,list_end);
list_end=0;
} else
if(chunksize>0) stream_skip(demuxer->stream,chunksize); else
if((int)chunksize<0) mp_msg(MSGT_HEADER,MSGL_WARN,"chunksize=%u (id=%.4s)\n",chunksize,(char *) &id);
}
// returns DEMUXER_TYPE_AAC_ADIF if this is an ADIF file, 0 otherwise.
static int demux_probe_aac_adif(demuxer_t *demuxer)
{
char c;
int i;
int len, srate, num;
off_t init, probed;
aac_adif_priv_t *priv;
aac_adif_hdr_contents* hdr;
if(! demux_aac_adif_init(demuxer))
{
mp_msg(MSGT_DEMUX, MSGL_ERR, "Couldn't init ADIF demuxer, exit\n");
return 0;
}
priv = (aac_adif_priv_t *) demuxer->priv;
hdr = priv->hdr;
stream_seek(demuxer->stream, 0);
c = stream_read_char(demuxer->stream);
if (c != 'A') goto fail;
c = stream_read_char(demuxer->stream);
if (c != 'D') goto fail;
c = stream_read_char(demuxer->stream);
if (c != 'I') goto fail;
c = stream_read_char(demuxer->stream);
if (c != 'F') goto fail;
resync_adif_bit_reader();
if (hdr->copyright_id_present = get_adif_onebit(demuxer))
{
for (i = 0; i < 9; i++)
hdr->copyright_id[i] = get_adif_bits(demuxer,8);
}
hdr->original_copy = get_adif_onebit(demuxer);
hdr->home = get_adif_onebit(demuxer);
hdr->bitstream_type = get_adif_onebit(demuxer);
hdr->bitrate = get_adif_bits(demuxer,23);
priv->bitrate = hdr->bitrate;
if (hdr->num_pces = (get_adif_bits(demuxer,4) + 1))
{
if (hdr->bitstream_type == 0)
{
if (! (hdr->buffer_fullness = (unsigned int*) calloc(hdr->num_pces, 20)))
{
mp_msg(MSGT_DEMUX, MSGL_ERR, "Could\'t initialise the ADIF buffer_fullness memory, exit\n");
return 0;
}
}
else
hdr->buffer_fullness = 0;
if (! (hdr->pces = (aac_adif_prog_config_elt*) calloc(hdr->num_pces, sizeof(aac_adif_prog_config_elt))))
{
mp_msg(MSGT_DEMUX, MSGL_ERR, "Could\'t initialise the ADIF program config element memory, exit\n");
return 0;
}
for (i = 0; i < hdr->num_pces; i++)
{
if ((hdr->bitstream_type == 0) && (hdr->buffer_fullness))
hdr->buffer_fullness[i] = get_adif_bits(demuxer,20);
if (hdr->pces)
read_adif_pce(demuxer, &hdr->pces[i]);
}
}
else
{
hdr->buffer_fullness = 0;
hdr->pces = 0;
}
init = probed = stream_tell(demuxer->stream);
priv->hdrlen = stream_tell(demuxer->stream);
mp_msg(MSGT_DEMUX, MSGL_V, "demux_aac_adif_probe, INIT: %"PRIu64", PROBED: %"PRIu64"\n", init, probed);
return DEMUXER_TYPE_AAC_ADIF;
fail:
mp_msg(MSGT_DEMUX, MSGL_V, "demux_aac_adif_probe, failed to detect an AAC_ADIF stream\n");
return 0;
}
static void read_adif_pce(demuxer_t *demuxer, aac_adif_prog_config_elt *elt)
{
int i;
aac_adif_priv_t *priv = (aac_adif_priv_t *) demuxer->priv;
elt->element_instance_tag = (char) get_adif_bits(demuxer, 4);
elt->object_type = (char) get_adif_bits(demuxer, 2);
elt->sampling_frequency_index = (char) get_adif_bits(demuxer, 4);
if ((priv->srate == 0) && (elt->sampling_frequency_index >= 0) && (elt->sampling_frequency_index < NUM_SAMPLE_RATES))
priv->srate = sample_rates[elt->sampling_frequency_index];
elt->num_front_channel_elements = (char) get_adif_bits(demuxer, 4);
elt->num_side_channel_elements = (char) get_adif_bits(demuxer, 4);
elt->num_back_channel_elements = (char) get_adif_bits(demuxer, 4);
elt->num_lfe_channel_elements = (char) get_adif_bits(demuxer, 2);
elt->num_assoc_data_elements = (char) get_adif_bits(demuxer, 3);
elt->num_valid_cc_elements = (char) get_adif_bits(demuxer, 4);
elt->mono_mixdown_present = (char) get_adif_bits(demuxer, 1);
if (elt->mono_mixdown_present)
elt->mono_mixdown_element_number = (char) get_adif_bits(demuxer, 4);
elt->stereo_mixdown_present = (char) get_adif_bits(demuxer, 1);
if (elt->stereo_mixdown_present)
elt->stereo_mixdown_element_number = (char) get_adif_bits(demuxer, 4);
elt->matrix_mixdown_idx_present = (char) get_adif_bits(demuxer, 1);
if (elt->matrix_mixdown_idx_present){
elt->matrix_mixdown_idx = (char) get_adif_bits(demuxer, 2);
elt->pseudo_surround_enable = (char) get_adif_bits(demuxer, 1);
}
if (elt->num_front_channel_elements)
{
elt->front_elements = (pce_element_info*) calloc(elt->num_front_channel_elements, sizeof(pce_element_info));
for (i = 0; i < elt->num_front_channel_elements; i++)
read_adif_pce_element_info(demuxer, &elt->front_elements[i]);
}
else
elt->front_elements = 0;
if (elt->num_side_channel_elements)
{
elt->side_elements = (pce_element_info*) calloc(elt->num_side_channel_elements, sizeof(pce_element_info));
for (i = 0; i < elt->num_side_channel_elements; i++)
read_adif_pce_element_info(demuxer, &elt->side_elements[i]);
}
else
elt->side_elements = 0;
if (elt->num_back_channel_elements)
{
elt->back_elements = (pce_element_info*) calloc(elt->num_back_channel_elements, sizeof(pce_element_info));
for (i = 0; i < elt->num_back_channel_elements; i++)
read_adif_pce_element_info(demuxer, &elt->back_elements[i]);
}
else
elt->back_elements = 0;
if (elt->num_lfe_channel_elements)
{
elt->lfe_elt_tag_selecti = (char*) malloc(elt->num_lfe_channel_elements);
for (i = 0; i < elt->num_lfe_channel_elements; i++)
elt->lfe_elt_tag_selecti[i] = (char) get_adif_bits(demuxer, 4);
}
else
elt->lfe_elt_tag_selecti = 0;
if (elt->num_assoc_data_elements)
{
elt->assoc_data_tag_selecti = (char*) malloc(elt->num_assoc_data_elements);
for (i = 0; i < elt->num_assoc_data_elements; i++)
elt->assoc_data_tag_selecti[i] = (char) get_adif_bits(demuxer, 4);
}
else
elt->assoc_data_tag_selecti = 0;
if (elt->num_valid_cc_elements)
{
elt->cc_elements = (pce_element_info*) calloc(elt->num_valid_cc_elements, sizeof(pce_element_info));;
for (i = 0; i < elt->num_back_channel_elements; i++)
read_adif_pce_element_info(demuxer, &elt->cc_elements[i]);
}
else
elt->cc_elements = 0;
resync_adif_bit_reader();
if (elt->comment_field_bytes = stream_read_char(demuxer->stream))
{
elt->comment_field_data = (char*) malloc(elt->comment_field_bytes);
for (i = 0; i < elt->comment_field_bytes; i++)
elt->comment_field_data[i] = stream_read_char(demuxer->stream);
}
else
elt->comment_field_data = 0;
}
if((c>>6)==1){ // Read (skip) STD scale & size value
// printf(" STD_scale=%d",(c>>5)&1);
d=((c&0x1F)<<8)|stream_read_char(demux->stream);
len-=2;
// printf(" STD_size=%d",d);
c=stream_read_char(demux->stream);
}
// Read System-1 stream timestamps:
if((c>>4)==2){
pts=read_mpeg_timestamp(demux->stream,c);
set_pts=1;
len-=4;
} else
if((c>>4)==3){
pts=read_mpeg_timestamp(demux->stream,c);
c=stream_read_char(demux->stream);
if((c>>4)!=1) pts=0; //printf("{ERROR4}");
else set_pts = 1;
dts=read_mpeg_timestamp(demux->stream,c);
len-=4+1+4;
} else
if((c>>6)==2){
int pts_flags;
int hdrlen;
int parse_ext2;
// System-2 (.VOB) stream:
c=stream_read_char(demux->stream);
pts_flags=c>>6;
parse_ext2 = (id == 0x1FD) && ((c & 0x3F) == 1);
c=stream_read_char(demux->stream);
hdrlen=c;