自学教程：C++ stream_read_char函数代码示例

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 packetstatic 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;}

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 otherwisestatic 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;	}}

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 packetstatic 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;//.........这里部分代码省略.........

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//.........这里部分代码省略.........

// 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;