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

static void _make_decode_ready(OggVorbis_File *vf){  if(vf->ready_state!=STREAMSET)return;  if(vf->seekable){    vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link);  }else{    vorbis_synthesis_init(&vf->vd,vf->vi);  }      vorbis_block_init(&vf->vd,&vf->vb);  vf->ready_state=INITSET;  return;}

int ovd_header_init(ovd_handle* handle){	if (handle->init < 2) {		if (handle->init < 0)			return -1;		while (handle->init < 2) {			int result = ogg_sync_pageout(handle->oy, &handle->og);			if (result == 0) 				return FALSE; // need more data			if (result == 1) {				ogg_stream_pagein(handle->os, &handle->og);				while(handle->init < 2){					result = ogg_stream_packetout(handle->os, &handle->op);					if (result == 0)						return 0; // need more data					if (result < 0) {						handle->init = -1; // fatal error						return -1;					}					vorbis_synthesis_headerin(&handle->vi, &handle->vc, &handle->op);					handle->init++;				}			}			else if (result = -1) return -1;		}				vorbis_synthesis_init(&handle->vd, &handle->vi);		vorbis_block_init(&handle->vd, &handle->vb);		return 1;	}	return 1;}

static int oggvorbis_decode_init(AVCodecContext *avccontext) {    OggVorbisContext *context = avccontext->priv_data ;    uint8_t *p= avccontext->extradata;    int i;    vorbis_info_init(&context->vi) ;    vorbis_comment_init(&context->vc) ;    for(i=0; i<3; i++){        context->op.b_o_s= i==0;        context->op.bytes= *(p++)<<8;        context->op.bytes+=*(p++);        context->op.packet= p;        p += context->op.bytes;	if(vorbis_synthesis_headerin(&context->vi, &context->vc, &context->op)<0){            av_log(avccontext, AV_LOG_ERROR, "%d. vorbis header damaged/n", i+1);            return -1;        }    }    avccontext->channels = context->vi.channels;    avccontext->sample_rate = context->vi.rate;    vorbis_synthesis_init(&context->vd, &context->vi);    vorbis_block_init(&context->vd, &context->vb);     return 0 ;}

FXbool VorbisDecoder::init_decoder() {  const FXuchar * data_ptr = get_packet_offset();  // Initialize Info  init_info();  while(get_next_packet()) {    if (is_vorbis_header()) {      if (vorbis_synthesis_headerin(&info,&comment,&op)<0) {        GM_DEBUG_PRINT("[vorbis] vorbis_synthesis_headerin failed/n");        return false;        }      }    else { // First non header      if (vorbis_synthesis_init(&dsp,&info)<0)        return false;      if (vorbis_block_init(&dsp,&block)<0) {        vorbis_dsp_clear(&dsp);        return false;        }      has_dsp=true;      push_back_packet();      return true;      }    }  vorbis_info_clear(&info);  set_packet_offset(data_ptr);  return true;  }

int vorbis_decode_init(vorbis_ctx **pv, const ogg_packet *pkt){	int r;	vorbis_ctx *v;	if (*pv == NULL) {		if (NULL == (v = calloc(1, sizeof(vorbis_ctx))))			return OV_EFAULT;		vorbis_info_init(&v->info);		if (0 != (r = vorbis_synthesis_headerin(&v->info, NULL, (void*)pkt)))			goto err;		*pv = v;		return 0;	}	v = *pv;	if (0 != (r = vorbis_synthesis_headerin(&v->info, NULL, (void*)pkt)))		goto err;	if (0 != (r = vorbis_synthesis_init(&v->ds, &v->info)))		goto err;	vorbis_block_init(&v->ds, &v->blk);	return 0;err:	free(v);	*pv = NULL;	return r;}

int VorbisDecode(Vorbis *vorbis, void *buffer, int buflen, AVCallback callback, long streamend, long granulepos) {  // setup ogg packet  vorbis->ogg.packet = buffer;  vorbis->ogg.bytes = buflen;    int status = 0;  if (vorbis->headers < 3) {    status = vorbis_synthesis_headerin(&vorbis->info, &vorbis->comment, &vorbis->ogg);        vorbis->headers++;    if (status == 0 && vorbis->headers == 3) {      vorbis->outlen /= vorbis->info.channels;            status = vorbis_synthesis_init(&vorbis->dsp, &vorbis->info);      if (status == 0)        status = vorbis_block_init(&vorbis->dsp, &vorbis->block);    }  } else {    // decode    status = vorbis_synthesis(&vorbis->block, &vorbis->ogg);    if (status == 0)      status = vorbis_synthesis_blockin(&vorbis->dsp, &vorbis->block);        int samples = 0;    float **pcm;    int cutoff = granulepos - vorbis->lastgranule;    while ((samples = vorbis_synthesis_pcmout(&vorbis->dsp, &pcm)) > 0) {            // interleave      int channels = vorbis->info.channels;      int len = samples < vorbis->outlen ? samples : vorbis->outlen;      if(streamend) {        len = len > cutoff ? cutoff : len;        cutoff -= len;      }            for (int i = 0; i < channels; i++) {        float *buf = &vorbis->outbuf[i];                for (int j = 0; j < len; j++) {          *buf = pcm[i][j];          buf += channels;        }      }            status = vorbis_synthesis_read(&vorbis->dsp, len);      callback(len * channels);      if(streamend && cutoff <= 0)        break;    }  }    if (vorbis->ogg.b_o_s)    vorbis->ogg.b_o_s = 0;  if(granulepos > 0)    vorbis->lastgranule = granulepos;    return status;}

TheoraDecoder::VorbisAudioTrack::VorbisAudioTrack(Audio::Mixer::SoundType soundType, vorbis_info &vorbisInfo) : _soundType(soundType) {	vorbis_synthesis_init(&_vorbisDSP, &vorbisInfo);	vorbis_block_init(&_vorbisDSP, &_vorbisBlock);	info = &vorbisInfo;	_audStream = Audio::makeQueuingAudioStream(vorbisInfo.rate, vorbisInfo.channels != 1);	_audioBufferFill = 0;	_audioBuffer = 0;	_endOfAudio = false;}

RefPtr<MediaDataDecoder::InitPromise>VorbisDataDecoder::Init(){  vorbis_info_init(&mVorbisInfo);  vorbis_comment_init(&mVorbisComment);  PodZero(&mVorbisDsp);  PodZero(&mVorbisBlock);  AutoTArray<unsigned char*,4> headers;  AutoTArray<size_t,4> headerLens;  if (!XiphExtradataToHeaders(headers, headerLens,                              mInfo.mCodecSpecificConfig->Elements(),                              mInfo.mCodecSpecificConfig->Length())) {    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);  }  for (size_t i = 0; i < headers.Length(); i++) {    if (NS_FAILED(DecodeHeader(headers[i], headerLens[i]))) {      return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR,                                          __func__);    }  }  MOZ_ASSERT(mPacketCount == 3);  int r = vorbis_synthesis_init(&mVorbisDsp, &mVorbisInfo);  if (r) {    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);  }  r = vorbis_block_init(&mVorbisDsp, &mVorbisBlock);  if (r) {    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);  }  if (mInfo.mRate != (uint32_t)mVorbisDsp.vi->rate) {    LOG(LogLevel::Warning,        ("Invalid Vorbis header: container and codec rate do not match!"));  }  if (mInfo.mChannels != (uint32_t)mVorbisDsp.vi->channels) {    LOG(LogLevel::Warning,        ("Invalid Vorbis header: container and codec channels do not match!"));  }  AudioConfig::ChannelLayout layout(mVorbisDsp.vi->channels);  if (!layout.IsValid()) {    return InitPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);  }  return InitPromise::CreateAndResolve(TrackInfo::kAudioTrack, __func__);}

nsresultVorbisDataDecoder::Init(){  vorbis_info_init(&mVorbisInfo);  vorbis_comment_init(&mVorbisComment);  PodZero(&mVorbisDsp);  PodZero(&mVorbisBlock);  size_t available = mInfo.mCodecSpecificConfig->Length();  uint8_t *p = mInfo.mCodecSpecificConfig->Elements();  for(int i = 0; i < 3; i++) {    if (available < 2) {      return NS_ERROR_FAILURE;    }    available -= 2;    size_t length = BigEndian::readUint16(p);    p += 2;    if (available < length) {      return NS_ERROR_FAILURE;    }    available -= length;    if (NS_FAILED(DecodeHeader((const unsigned char*)p, length))) {        return NS_ERROR_FAILURE;    }    p += length;  }  MOZ_ASSERT(mPacketCount == 3);  int r = vorbis_synthesis_init(&mVorbisDsp, &mVorbisInfo);  if (r) {    return NS_ERROR_FAILURE;  }  r = vorbis_block_init(&mVorbisDsp, &mVorbisBlock);  if (r) {    return NS_ERROR_FAILURE;  }  if (mInfo.mRate != (uint32_t)mVorbisDsp.vi->rate) {    LOG(LogLevel::Warning,        ("Invalid Vorbis header: container and codec rate do not match!"));  }  if (mInfo.mChannels != (uint32_t)mVorbisDsp.vi->channels) {    LOG(LogLevel::Warning,        ("Invalid Vorbis header: container and codec channels do not match!"));  }  return NS_OK;}

static GstFlowReturnvorbis_handle_type_packet (GstVorbisDec * vd){  GList *walk;  gint res;  g_assert (vd->initialized == FALSE);#ifdef USE_TREMOLO  if (G_UNLIKELY ((res = vorbis_dsp_init (&vd->vd, &vd->vi))))    goto synthesis_init_error;#else  if (G_UNLIKELY ((res = vorbis_synthesis_init (&vd->vd, &vd->vi))))    goto synthesis_init_error;  if (G_UNLIKELY ((res = vorbis_block_init (&vd->vd, &vd->vb))))    goto block_init_error;#endif  vd->initialized = TRUE;  if (vd->pendingevents) {    for (walk = vd->pendingevents; walk; walk = g_list_next (walk))      gst_pad_push_event (vd->srcpad, GST_EVENT_CAST (walk->data));    g_list_free (vd->pendingevents);    vd->pendingevents = NULL;  }  if (vd->taglist) {    /* The tags have already been sent on the bus as messages. */    gst_pad_push_event (vd->srcpad, gst_event_new_tag (vd->taglist));    vd->taglist = NULL;  }  return GST_FLOW_OK;  /* ERRORS */synthesis_init_error:  {    GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,        (NULL), ("couldn't initialize synthesis (%d)", res));    return GST_FLOW_ERROR;  }block_init_error:  {    GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,        (NULL), ("couldn't initialize block (%d)", res));    return GST_FLOW_ERROR;  }}

/* * Class:     org_tritonus_lowlevel_pvorbis_DspState * Method:    initSynthesis_native * Signature: (Lorg/tritonus/lowlevel/vorbis/Info;)I */JNIEXPORT jint JNICALLJava_org_tritonus_lowlevel_pvorbis_DspState_initSynthesis_1native(JNIEnv* env, jobject obj, jobject info){	vorbis_dsp_state*	handle;	vorbis_info*		infoHandle;	int			nReturn;	if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_pvorbis_DspState_initSynthesis(): begin/n"); }	handle = getHandle(env, obj);	infoHandle = getInfoNativeHandle(env, info);	nReturn = vorbis_synthesis_init(handle, infoHandle);	if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_pvorbis_DspState_initSynthesis(): end/n"); }	return nReturn;}

static void *vorbis_thread(void *arg) {	int res, n;	char *oggbuf;	time_t now;	VORBIS_FEED *feed;	feed = (VORBIS_FEED *)arg;	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);	pthread_mutex_lock(&(feed->base.thread_lock));	if (vorbis_synthesis_init(&(feed->vd), &(feed->vi)) != 0) {		logmsg("vorbis init failed/n");		return NULL;		}	feed->base.running = 1;	if (feeds == NULL) feeds = new_unit();	link_unit((MASH_UNIT *)feed, feeds);	vorbis_block_init(&(feed->vd), &(feed->vb));	while (feed->base.running) {		while (1) {			res = ogg_sync_pageout(&(feed->oy), &(feed->og));			if (res == 0) break;			if (res < 0) {				logmsg("missing data/n");				continue;				}			res = ogg_stream_pagein(&(feed->os), &(feed->og));			if (res < 0) {				ogg_stream_reset(&(feed->os));				ogg_stream_init(&(feed->os),					ogg_page_serialno(&(feed->og)));				now = time(NULL);				logmsg("%s: bad ogg page/n", ctime(&now));				continue;				}			process_vorbis_packets(feed);			}		pthread_cond_wait(&(feed->base.data_ready),				&(feed->base.thread_lock));		oggbuf = ogg_sync_buffer(&(feed->oy), BLOCKSIZE);		n = read(feed->base.sock, oggbuf, BLOCKSIZE);		ogg_sync_wrote(&(feed->oy), n);		}	pthread_mutex_unlock(&(feed->base.thread_lock));	return NULL;	}

PRBool nsVorbisState::Init(){  if (!mActive)    return PR_FALSE;  int ret = vorbis_synthesis_init(&mDsp, &mInfo);  if (ret != 0) {    NS_WARNING("vorbis_synthesis_init() failed initializing vorbis bitstream");    return mActive = PR_FALSE;  }  ret = vorbis_block_init(&mDsp, &mBlock);  if (ret != 0) {    NS_WARNING("vorbis_block_init() failed initializing vorbis bitstream");    if (mActive) {      vorbis_dsp_clear(&mDsp);    }    return mActive = PR_FALSE;  }  return PR_TRUE;}

bool VorbisState::Init(){  if (!mActive)    return false;  int ret = vorbis_synthesis_init(&mDsp, &mInfo);  if (ret != 0) {    NS_WARNING("vorbis_synthesis_init() failed initializing vorbis bitstream");    return mActive = false;  }  ret = vorbis_block_init(&mDsp, &mBlock);  if (ret != 0) {    NS_WARNING("vorbis_block_init() failed initializing vorbis bitstream");    if (mActive) {      vorbis_dsp_clear(&mDsp);    }    return mActive = false;  }  return true;}

bool OggVorbisDecoder::_init(){      // Read header packets.      bool haveVorbisHeader = true;   for( U32 i = 0; i < 2; ++ i )   {      ogg_packet nextPacket;      if( !_readNextPacket( &nextPacket ) )      {         haveVorbisHeader = false;         break;      }                int result = vorbis_synthesis_headerin( &mVorbisInfo, &mVorbisComment, &nextPacket );      if( result != 0 )      {         haveVorbisHeader = false;         break;      }   }      // Fail if we don't have a complete and valid Vorbis header.      if( !haveVorbisHeader )   {      vorbis_info_clear( &mVorbisInfo );      vorbis_comment_clear( &mVorbisComment );            Con::errorf( "OggVorbisDecoder::_init() - Incorrect or corrupt Vorbis headers" );            return false;   }      // Init synthesis.      vorbis_synthesis_init( &mVorbisDspState, &mVorbisInfo );   vorbis_block_init( &mVorbisDspState, &mVorbisBlock );      return true;}

static int UpdateInput(vorbis* p){	vorbis_block_clear(&p->Block);	vorbis_dsp_clear(&p->DSP);	if (p->Codec.In.Format.Type == PACKET_AUDIO)	{		vorbis_info* Info = (vorbis_info*)p->Codec.In.Format.Extra;		if (Info)		{			vorbis_synthesis_init(&p->DSP,Info);			vorbis_block_init(&p->DSP,&p->Block);			p->Codec.In.Format.ByteRate = Info->bitrate_nominal >> 3;			p->Codec.In.Format.Format.Audio.SampleRate = Info->rate;			p->Codec.In.Format.Format.Audio.Channels = Info->channels;		}		PacketFormatPCM(&p->Codec.Out.Format,&p->Codec.In.Format,OGG_F_BITS+1);		p->Codec.Out.Format.Format.Audio.Flags = PCM_PLANES;	}

 void hSoundResource::hPlaybackInfo::Init( vorbis_info* vobinfo, hUint32 initTell ) {     hUint32 er;     er = vorbis_synthesis_init( &vobDSP_, vobinfo );     hcAssert( er == 0 );     vorbis_block_init( &vobDSP_, &vobBlock_ );       tell_ = initTell;     readOpID_ = ~0U;     maxDecodeSamples_ = PCM_BUFFER_SIZE;     currentOutBuffer_ = 0;     currentDecodeSamples_ = 0;     inSizes = 0;     hZeroMem( outSizes, sizeof(outSizes) );     hZeroMem( inBuffer_, sizeof(inBuffer_) );     hZeroMem( outBuffers_, sizeof(outBuffers_) );     inUse_ = hTrue;     eos_ = hFalse;     eoSource_ = hFalse;     state_ = OGGDecode_NEED_MORE_DATA;     decodingBlock = hFalse; }

static GstFlowReturnvorbis_handle_type_packet (GstVorbisDec * vd){  gint res;  g_assert (vd->initialized == FALSE);#ifdef USE_TREMOLO  if (G_UNLIKELY ((res = vorbis_dsp_init (&vd->vd, &vd->vi))))    goto synthesis_init_error;#else  if (G_UNLIKELY ((res = vorbis_synthesis_init (&vd->vd, &vd->vi))))    goto synthesis_init_error;  if (G_UNLIKELY ((res = vorbis_block_init (&vd->vd, &vd->vb))))    goto block_init_error;#endif  vd->initialized = TRUE;  return GST_FLOW_OK;  /* ERRORS */synthesis_init_error:  {    GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,        (NULL), ("couldn't initialize synthesis (%d)", res));    return GST_FLOW_ERROR;  }block_init_error:  {    GST_ELEMENT_ERROR (GST_ELEMENT (vd), STREAM, DECODE,        (NULL), ("couldn't initialize block (%d)", res));    return GST_FLOW_ERROR;  }}

/***************************************************************************** * ProcessHeaders: process Vorbis headers. *****************************************************************************/static int ProcessHeaders( decoder_t *p_dec ){    decoder_sys_t *p_sys = p_dec->p_sys;    ogg_packet oggpacket;    unsigned pi_size[XIPH_MAX_HEADER_COUNT];    void *pp_data[XIPH_MAX_HEADER_COUNT];    unsigned i_count;    if( xiph_SplitHeaders( pi_size, pp_data, &i_count,                           p_dec->fmt_in.i_extra, p_dec->fmt_in.p_extra) )        return VLC_EGENERIC;    if( i_count < 3 )        return VLC_EGENERIC;    oggpacket.granulepos = -1;    oggpacket.e_o_s = 0;    oggpacket.packetno = 0;    /* Take care of the initial Vorbis header */    oggpacket.b_o_s  = 1; /* yes this actually is a b_o_s packet :) */    oggpacket.bytes  = pi_size[0];    oggpacket.packet = pp_data[0];    if( vorbis_synthesis_headerin( &p_sys->vi, &p_sys->vc, &oggpacket ) < 0 )    {        msg_Err( p_dec, "this bitstream does not contain Vorbis audio data");        return VLC_EGENERIC;    }    /* Setup the format */    p_dec->fmt_out.audio.i_rate     = p_sys->vi.rate;    p_dec->fmt_out.audio.i_channels = p_sys->vi.channels;    if( p_dec->fmt_out.audio.i_channels >= ARRAY_SIZE(pi_channels_maps) )    {        msg_Err( p_dec, "invalid number of channels (1-%zu): %i",                 ARRAY_SIZE(pi_channels_maps),                 p_dec->fmt_out.audio.i_channels );        return VLC_EGENERIC;    }    p_dec->fmt_out.audio.i_physical_channels =        p_dec->fmt_out.audio.i_original_channels =            pi_channels_maps[p_sys->vi.channels];    p_dec->fmt_out.i_bitrate = __MAX( 0, (int32_t) p_sys->vi.bitrate_nominal );    date_Init( &p_sys->end_date, p_sys->vi.rate, 1 );    msg_Dbg( p_dec, "channels:%d samplerate:%ld bitrate:%ud",             p_sys->vi.channels, p_sys->vi.rate, p_dec->fmt_out.i_bitrate );    /* The next packet in order is the comments header */    oggpacket.b_o_s  = 0;    oggpacket.bytes  = pi_size[1];    oggpacket.packet = pp_data[1];    if( vorbis_synthesis_headerin( &p_sys->vi, &p_sys->vc, &oggpacket ) < 0 )    {        msg_Err( p_dec, "2nd Vorbis header is corrupted" );        return VLC_EGENERIC;    }    ParseVorbisComments( p_dec );    /* The next packet in order is the codebooks header     * We need to watch out that this packet is not missing as a     * missing or corrupted header is fatal. */    oggpacket.b_o_s  = 0;    oggpacket.bytes  = pi_size[2];    oggpacket.packet = pp_data[2];    if( vorbis_synthesis_headerin( &p_sys->vi, &p_sys->vc, &oggpacket ) < 0 )    {        msg_Err( p_dec, "3rd Vorbis header is corrupted" );        return VLC_EGENERIC;    }    if( !p_sys->b_packetizer )    {        /* Initialize the Vorbis packet->PCM decoder */        vorbis_synthesis_init( &p_sys->vd, &p_sys->vi );        vorbis_block_init( &p_sys->vd, &p_sys->vb );    }    else    {        p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;        p_dec->fmt_out.p_extra = xrealloc( p_dec->fmt_out.p_extra,                                           p_dec->fmt_out.i_extra );        memcpy( p_dec->fmt_out.p_extra,                p_dec->fmt_in.p_extra, p_dec->fmt_out.i_extra );    }    ConfigureChannelOrder(p_sys->pi_chan_table, p_sys->vi.channels,                          p_dec->fmt_out.audio.i_physical_channels, true);    return VLC_SUCCESS;}

//.........这里部分代码省略.........  mp_msg(MSGT_DECAUDIO,MSGL_V,"ad_vorbis, extradata seems is %d bytes long/n", sh->wf->cbSize);  extradata = (char*) (sh->wf+1);  if(*extradata != 2) {    mp_msg (MSGT_DEMUX, MSGL_WARN, "ad_vorbis: Vorbis track does not contain valid headers./n");    ERROR();  }  offset = 1;  for (i=0; i < 2; i++) {    length = 0;    while ((extradata[offset] == (unsigned char) 0xFF) && length < sh->wf->cbSize) {      length += 255;      offset++;    }    if(offset >= (sh->wf->cbSize - 1)) {      mp_msg (MSGT_DEMUX, MSGL_WARN, "ad_vorbis: Vorbis track does not contain valid headers./n");      ERROR();    }    length += extradata[offset];    offset++;    mp_msg (MSGT_DEMUX, MSGL_V, "ad_vorbis, offset: %u, length: %u/n", offset, length);    hsizes[i] = length;  }  headers[0] = &extradata[offset];  headers[1] = &extradata[offset + hsizes[0]];  headers[2] = &extradata[offset + hsizes[0] + hsizes[1]];  hsizes[2] = sh->wf->cbSize - offset - hsizes[0] - hsizes[1];  mp_msg (MSGT_DEMUX, MSGL_V, "ad_vorbis, header sizes: %d %d %d/n", hsizes[0], hsizes[1], hsizes[2]);  for(i=0; i<3; i++) {    op.bytes = hsizes[i];    op.packet = headers[i];    op.b_o_s  = (i == 0);    if(vorbis_synthesis_headerin(&ov->vi,&vc,&op) <0) {      mp_msg(MSGT_DECAUDIO,MSGL_ERR,"OggVorbis: header n. %d broken! len=%ld/n", i, op.bytes);      ERROR();    }    if(i == 2) {      float rg_gain=0.f, rg_peak=0.f;    char **ptr=vc.user_comments;    while(*ptr){      mp_msg(MSGT_DECAUDIO,MSGL_V,"OggVorbisComment: %s/n",*ptr);      /* replaygain */      read_vorbis_comment( *ptr, "replaygain_album_gain=", "%f", &rg_gain );      read_vorbis_comment( *ptr, "rg_audiophile=", "%f", &rg_gain );      if( !rg_gain ) {	read_vorbis_comment( *ptr, "replaygain_track_gain=", "%f", &rg_gain );	read_vorbis_comment( *ptr, "rg_radio=", "%f", &rg_gain );      }      read_vorbis_comment( *ptr, "replaygain_album_peak=", "%f", &rg_peak );      if( !rg_peak ) {	read_vorbis_comment( *ptr, "replaygain_track_peak=", "%f", &rg_peak );	read_vorbis_comment( *ptr, "rg_peak=", "%f", &rg_peak );      }      ++ptr;    }    /* replaygain: scale */    if(!rg_gain)      ov->rg_scale = 1.f; /* just in case pow() isn't standard-conformant */    else      ov->rg_scale = pow(10.f, rg_gain/20);    /* replaygain: anticlip */    if(ov->rg_scale * rg_peak > 1.f)      ov->rg_scale = 1.f / rg_peak;    /* replaygain: security */    if(ov->rg_scale > 15.)      ov->rg_scale = 15.;#ifdef CONFIG_TREMOR    ov->rg_scale_int = (int)(ov->rg_scale*64.f);#endif    mp_msg(MSGT_DECAUDIO,MSGL_V,"OggVorbis: Bitstream is %d channel%s, %dHz, %dbit/s %cBR/n",(int)ov->vi.channels,ov->vi.channels>1?"s":"",(int)ov->vi.rate,(int)ov->vi.bitrate_nominal,	(ov->vi.bitrate_lower!=ov->vi.bitrate_nominal)||(ov->vi.bitrate_upper!=ov->vi.bitrate_nominal)?'V':'C');    if(rg_gain || rg_peak)      mp_msg(MSGT_DECAUDIO,MSGL_V,"OggVorbis: Gain = %+.2f dB, Peak = %.4f, Scale = %.2f/n", rg_gain, rg_peak, ov->rg_scale);    mp_msg(MSGT_DECAUDIO,MSGL_V,"OggVorbis: Encoded by: %s/n",vc.vendor);    }  }  vorbis_comment_clear(&vc);//  printf("lower=%d  upper=%d  /n",(int)ov->vi.bitrate_lower,(int)ov->vi.bitrate_upper);  // Setup the decoder  sh->channels=ov->vi.channels;  sh->samplerate=ov->vi.rate;  sh->samplesize=2;  // assume 128kbit if bitrate not specified in the header  sh->i_bps=((ov->vi.bitrate_nominal>0) ? ov->vi.bitrate_nominal : 128000)/8;  sh->context = ov;  /// Finish the decoder init  vorbis_synthesis_init(&ov->vd,&ov->vi);  vorbis_block_init(&ov->vd,&ov->vb);  mp_msg(MSGT_DECAUDIO,MSGL_V,"OggVorbis: Init OK!/n");  return 1;}

//.........这里部分代码省略.........              exit(1);            }            i++;          }        }      }      /* no harm in not checking before adding more */      buffer=ogg_sync_buffer(&oy,4096);      //bytes=fread(buffer,1,4096,stdin);	  bytes=fread(buffer,1,4096,instream);      if(bytes==0 && i<2){        fprintf(stderr,"End of file before finding all Vorbis headers!/n");        exit(1);      }      ogg_sync_wrote(&oy,bytes);    }        /* Throw the comments plus a few lines about the bitstream we're       decoding */    {      char **ptr=vc.user_comments;      while(*ptr){        fprintf(stderr,"%s/n",*ptr);        ++ptr;      }      fprintf(stderr,"/nBitstream is %d channel, %ldHz/n",vi.channels,vi.rate);      fprintf(stderr,"Encoded by: %s/n/n",vc.vendor);    }        convsize=4096/vi.channels;    /* OK, got and parsed all three headers. Initialize the Vorbis       packet->PCM decoder. */    if(vorbis_synthesis_init(&vd,&vi)==0){ /* central decode state */      vorbis_block_init(&vd,&vb);          /* local state for most of the decode                                              so multiple block decodes can                                              proceed in parallel. We could init                                              multiple vorbis_block structures                                              for vd here */            /* The rest is just a straight decode loop until end of stream */      while(!eos){        while(!eos){          int result=ogg_sync_pageout(&oy,&og);          if(result==0)break; /* need more data */          if(result<0){ /* missing or corrupt data at this page position */            fprintf(stderr,"Corrupt or missing data in bitstream; "                    "continuing.../n");          }else{            ogg_stream_pagein(&os,&og); /* can safely ignore errors at                                           this point */            while(1){              result=ogg_stream_packetout(&os,&op);                            if(result==0)break; /* need more data */              if(result<0){ /* missing or corrupt data at this page position */                /* no reason to complain; already complained above */              }else{                /* we have a packet.  Decode it */                float **pcm;                int samples;                                if(vorbis_synthesis(&vb,&op)==0) /* test for success! */                  vorbis_synthesis_blockin(&vd,&vb);                /*                    

qboolean OGV_StartRead(cinematic_t *cin){	int        status;	ogg_page   og;	ogg_packet op;	int        i;	cin->data = Com_Allocate(sizeof(cin_ogv_t));	Com_Memset(cin->data, 0, sizeof(cin_ogv_t));	ogg_sync_init(&g_ogm->oy);  /* Now we can read pages */	//FIXME? can serialno be 0 in ogg? (better way to check inited?)	//TODO: support for more than one audio stream? / detect files with one stream(or without correct ones)	while (!g_ogm->os_audio.serialno || !g_ogm->os_video.serialno)	{		if (ogg_sync_pageout(&g_ogm->oy, &og) == 1)		{			if (strstr((char *)(og.body + 1), "vorbis"))			{				//FIXME? better way to find audio stream				if (g_ogm->os_audio.serialno)				{					Com_Printf(S_COLOR_YELLOW "WARNING: more than one audio stream, in ogm-file(%s) ... we will stay at the first one/n", cin->name);				}				else				{					ogg_stream_init(&g_ogm->os_audio, ogg_page_serialno(&og));					ogg_stream_pagein(&g_ogm->os_audio, &og);				}			}			if (strstr((char *)(og.body + 1), "theora"))			{				if (g_ogm->os_video.serialno)				{					Com_Printf(S_COLOR_YELLOW "WARNING: more than one video stream, in ogm-file(%s) ... we will stay at the first one/n", cin->name);				}				else				{					ogg_stream_init(&g_ogm->os_video, ogg_page_serialno(&og));					ogg_stream_pagein(&g_ogm->os_video, &og);				}			}		}		else if (OGV_LoadBlockToSync(cin))		{			break;		}	}	if (!g_ogm->os_audio.serialno)	{		Com_Printf(S_COLOR_YELLOW "WARNING: Haven't found a audio(vorbis) stream in ogm-file (%s)/n", cin->name);		return qfalse;	}	if (!g_ogm->os_video.serialno)	{		Com_Printf(S_COLOR_YELLOW "WARNING: Haven't found a video stream in ogm-file (%s)/n", cin->name);		return qfalse;	}	//load vorbis header	vorbis_info_init(&g_ogm->vi);	vorbis_comment_init(&g_ogm->vc);	i = 0;	while (i < 3)	{		status = ogg_stream_packetout(&g_ogm->os_audio, &op);		if (status < 0)		{			Com_Printf(S_COLOR_YELLOW "WARNING: Corrupt ogg packet while loading vorbis-headers, ogm-file(%s)/n", cin->name);			return qfalse;		}		if (status > 0)		{			status = vorbis_synthesis_headerin(&g_ogm->vi, &g_ogm->vc, &op);			if (i == 0 && status < 0)			{				Com_Printf(S_COLOR_YELLOW "WARNING: This Ogg bitstream does not contain Vorbis audio data, ogm-file(%s)/n", cin->name);				return qfalse;			}			++i;		}		else if (OGV_LoadPagesToStreams(cin))		{			if (OGV_LoadBlockToSync(cin))			{				Com_Printf(S_COLOR_YELLOW "WARNING: Couldn't find all vorbis headers before end of ogm-file (%s)/n", cin->name);				return qfalse;			}		}	}	vorbis_synthesis_init(&g_ogm->vd, &g_ogm->vi);	// Do init	{		theora_info_init(&g_ogm->th_info);		theora_comment_init(&g_ogm->th_comment);//.........这里部分代码省略.........

//.........这里部分代码省略.........		} ;	} ;	/*	**	At this point, we're sure we're Vorbis.	We've set up the logical (Ogg)	**	bitstream decoder. Get the comment and codebook headers and set up the	**	Vorbis decoder.	**	**	The next two packets in order are the comment and codebook headers.	**	They're likely large and may span multiple pages.  Thus we reead	**	and submit data until we get our two pacakets, watching that no	**	pages are missing.  If a page is missing, error out ; losing a	**	header page is the only place where missing data is fatal.	*/	i = 0 ;			/* Count of number of packets read */	while (i < 2)	{	int result = ogg_sync_pageout (&odata->osync, &odata->opage) ;		if (result == 0)		{	/* Need more data */			buffer = ogg_sync_buffer (&odata->osync, 4096) ;			bytes = psf_fread (buffer, 1, 4096, psf) ;			if (bytes == 0 && i < 2)			{	psf_log_printf (psf, "End of file before finding all Vorbis headers!/n") ;				return SFE_MALFORMED_FILE ;			} ;			nn = ogg_sync_wrote (&odata->osync, bytes) ;		}		else if (result == 1)		{	/*			**	Don't complain about missing or corrupt data yet. We'll			**	catch it at the packet output phase.			**			**	We can ignore any errors here as they'll also become apparent			**	at packetout.			*/			nn = ogg_stream_pagein (&odata->ostream, &odata->opage) ;			while (i < 2)			{	result = ogg_stream_packetout (&odata->ostream, &odata->opacket) ;				if (result == 0)					break ;				if (result < 0)				{	/*	Uh oh ; data at some point was corrupted or missing!					**	We can't tolerate that in a header. Die. */					psf_log_printf (psf, "Corrupt secondary header.	Exiting./n") ;					return SFE_MALFORMED_FILE ;				} ;				vorbis_synthesis_headerin (&vdata->vinfo, &vdata->vcomment, &odata->opacket) ;				i++ ;			} ;		} ;	} ;	if (log_data)	{	int printed_metadata_msg = 0 ;		int k ;		psf_log_printf (psf, "Bitstream is %d channel, %D Hz/n", vdata->vinfo.channels, vdata->vinfo.rate) ;		psf_log_printf (psf, "Encoded by : %s/n", vdata->vcomment.vendor) ;		/* Throw the comments plus a few lines about the bitstream we're decoding. */		for (k = 0 ; k < ARRAY_LEN (vorbis_metatypes) ; k++)		{	char *dd ;			dd = vorbis_comment_query (&vdata->vcomment, vorbis_metatypes [k].name, 0) ;			if (dd == NULL)				continue ;			if (printed_metadata_msg == 0)			{	psf_log_printf (psf, "Metadata :/n") ;				printed_metadata_msg = 1 ;			} ;			psf_store_string (psf, vorbis_metatypes [k].id, dd) ;			psf_log_printf (psf, "  %-10s : %s/n", vorbis_metatypes [k].name, dd) ;		} ;		psf_log_printf (psf, "End/n") ;	} ;	psf->sf.samplerate	= vdata->vinfo.rate ;	psf->sf.channels	= vdata->vinfo.channels ;	psf->sf.format		= SF_FORMAT_OGG | SF_FORMAT_VORBIS ;	/*	OK, got and parsed all three headers. Initialize the Vorbis	**	packet->PCM decoder.	**	Central decode state. */	vorbis_synthesis_init (&vdata->vdsp, &vdata->vinfo) ;	/*	Local state for most of the decode so multiple block decodes can	**	proceed in parallel. We could init multiple vorbis_block structures	**	for vd here. */	vorbis_block_init (&vdata->vdsp, &vdata->vblock) ;	vdata->loc = 0 ;	return 0 ;} /* vorbis_read_header */

//.........这里部分代码省略.........				fprintf(stderr, "Error parsing Theora stream headers; "								"corrupt stream?/n");				clear();				return;			}			theora_p++;		}		/* look for more vorbis header packets */		while (vorbis_p && (vorbis_p < 3) && (ret = ogg_stream_packetout(&vo, &op))) {			if (ret < 0) {				fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?/n");				clear();				return;			}			ret = vorbis_synthesis_headerin(&vi, &vc, &op);			if (ret) {				fprintf(stderr, "Error parsing Vorbis stream headers; corrupt stream?/n");				clear();				return;			}			vorbis_p++;			if (vorbis_p == 3) break;		}		/* The header pages/packets will arrive before anything else we		care about, or the stream is not obeying spec */		if (ogg_sync_pageout(&oy, &og) > 0) {			queue_page(&og); /* demux into the appropriate stream */		} else {			int ret = buffer_data(); /* someone needs more data */			if (ret == 0) {				fprintf(stderr, "End of file while searching for codec headers./n");				clear();				return;			}		}	}	/* and now we have it all.  initialize decoders */	if (theora_p) {		td = th_decode_alloc(&ti, ts);		printf("Ogg logical stream %lx is Theora %dx%d %.02f fps",				to.serialno, ti.pic_width, ti.pic_height,				(double)ti.fps_numerator / ti.fps_denominator);		px_fmt = ti.pixel_fmt;		switch (ti.pixel_fmt) {			case TH_PF_420: printf(" 4:2:0 video/n"); break;			case TH_PF_422: printf(" 4:2:2 video/n"); break;			case TH_PF_444: printf(" 4:4:4 video/n"); break;			case TH_PF_RSVD:			default:				printf(" video/n  (UNKNOWN Chroma sampling!)/n");				break;		}		if (ti.pic_width != ti.frame_width || ti.pic_height != ti.frame_height)			printf("  Frame content is %dx%d with offset (%d,%d)./n",					ti.frame_width, ti.frame_height, ti.pic_x, ti.pic_y);		th_decode_ctl(td, TH_DECCTL_GET_PPLEVEL_MAX, &pp_level_max,				sizeof(pp_level_max));		pp_level = 0;		th_decode_ctl(td, TH_DECCTL_SET_PPLEVEL, &pp_level, sizeof(pp_level));		pp_inc = 0;		int w;		int h;		w = (ti.pic_x + ti.frame_width + 1 & ~1) - (ti.pic_x & ~1);		h = (ti.pic_y + ti.frame_height + 1 & ~1) - (ti.pic_y & ~1);		size.x = w;		size.y = h;		texture->create(w, h, Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);	} else {		/* tear down the partial theora setup */		th_info_clear(&ti);		th_comment_clear(&tc);	}	th_setup_free(ts);	if (vorbis_p) {		vorbis_synthesis_init(&vd, &vi);		vorbis_block_init(&vd, &vb);		fprintf(stderr, "Ogg logical stream %lx is Vorbis %d channel %ld Hz audio./n",				vo.serialno, vi.channels, vi.rate);		//_setup(vi.channels, vi.rate);	} else {		/* tear down the partial vorbis setup */		vorbis_info_clear(&vi);		vorbis_comment_clear(&vc);	}	playing = false;	buffering = true;	time = 0;	audio_frames_wrote = 0;};

//.........这里部分代码省略.........    }    /* The header pages/packets will arrive before anything else we       care about, or the stream is not obeying spec */    if(ogg_sync_pageout(&oy,&og)>0){      queue_page(&og); /* demux into the appropriate stream */    }else{      int ret=buffer_data(infile,&oy); /* someone needs more data */      if(ret==0){        fprintf(stderr,"End of file while searching for codec headers./n");        exit(1);      }    }  }  /* and now we have it all.  initialize decoders */  if(theora_p){    theora_decode_init(&td,&ti);    printf("Ogg logical stream %x is Theora %dx%d %.02f fps video/n",           (unsigned int)to.serialno,ti.width,ti.height,            (double)ti.fps_numerator/ti.fps_denominator);    if(ti.width!=ti.frame_width || ti.height!=ti.frame_height)      printf("  Frame content is %dx%d with offset (%d,%d)./n",           ti.frame_width, ti.frame_height, ti.offset_x, ti.offset_y);    report_colorspace(&ti);    dump_comments(&tc);  }else{    /* tear down the partial theora setup */    theora_info_clear(&ti);    theora_comment_clear(&tc);  }  if(vorbis_p){    vorbis_synthesis_init(&vd,&vi);    vorbis_block_init(&vd,&vb);    fprintf(stderr,"Ogg logical stream %x is Vorbis %d channel %d Hz audio./n",            (unsigned int)vo.serialno,vi.channels,(int)vi.rate);  }else{    /* tear down the partial vorbis setup */    vorbis_info_clear(&vi);    vorbis_comment_clear(&vc);  }  /* open audio */  if(vorbis_p)open_audio();  /* open video */  if(theora_p)open_video();  /* install signal handler as SDL clobbered the default */  signal (SIGINT, sigint_handler);  /* on to the main decode loop.  We assume in this example that audio     and video start roughly together, and don't begin playback until     we have a start frame for both.  This is not necessarily a valid     assumption in Ogg A/V streams! It will always be true of the     example_encoder (and most streams) though. */  stateflag=0; /* playback has not begun */  while(!got_sigint){    /* we want a video and audio frame ready to go at all times.  If       we have to buffer incoming, buffer the compressed data (ie, let       ogg do the buffering) */    while(vorbis_p && !audiobuf_ready){      int ret;

//.........这里部分代码省略.........     header is an easy way to identify a Vorbis bitstream and it's     useful to see that functionality seperated out. */    vorbis_info_init(&vi);  vorbis_comment_init(&vc);  if(ogg_stream_pagein(&os,&og)<0){     /* error; stream version mismatch perhaps */    ERRORF( gfc, "Error reading first page of Ogg bitstream data./n" );    return -1;  }    if(ogg_stream_packetout(&os,&op)!=1){     /* no page? must not be vorbis */    ERRORF( gfc, "Error reading initial header packet./n" );    return -1;  }    if(vorbis_synthesis_headerin(&vi,&vc,&op)<0){     /* error case; not a vorbis header */    ERRORF( gfc, "This Ogg bitstream does not contain Vorbis "	    "audio data./n");    return -1;  }    /* At this point, we're sure we're Vorbis.  We've set up the logical     (Ogg) bitstream decoder.  Get the comment and codebook headers and     set up the Vorbis decoder */    /* The next two packets in order are the comment and codebook headers.     They're likely large and may span multiple pages.  Thus we reead     and submit data until we get our two pacakets, watching that no     pages are missing.  If a page is missing, error out; losing a     header page is the only place where missing data is fatal. */    i=0;  while(i<2){    while(i<2){      int result=ogg_sync_pageout(&oy,&og);      if(result==0)break; /* Need more data */      /* Don't complain about missing or corrupt data yet.  We'll	 catch it at the packet output phase */      if(result==1){	ogg_stream_pagein(&os,&og); /* we can ignore any errors here				       as they'll also become apparent				       at packetout */	while(i<2){	  result=ogg_stream_packetout(&os,&op);	  if(result==0)break;	  if(result==-1){	    /* Uh oh; data at some point was corrupted or missing!	       We can't tolerate that in a header.  Die. */	    ERRORF( gfc, "Corrupt secondary header.  Exiting./n" );	    return -1;	  }	  vorbis_synthesis_headerin(&vi,&vc,&op);	  i++;	}      }    }    /* no harm in not checking before adding more */    buffer=ogg_sync_buffer(&oy,4096);    bytes=fread(buffer,1,4096,fd);    if(bytes==0 && i<2){      ERRORF( gfc, "End of file before finding all Vorbis headers!/n" );      return -1;    }    ogg_sync_wrote(&oy,bytes);  }    /* Throw the comments plus a few lines about the bitstream we're     decoding */  {    /*    char **ptr=vc.user_comments;    while(*ptr){      MSGF( gfc, "%s/n", *ptr );      ++ptr;    }    MSGF( gfc, "/nBitstream is %d channel, %ldHz/n", vi.channels, vi.rate );    MSGF( gfc, "Encoded by: %s/n/n", vc.vendor );    */  }      /* OK, got and parsed all three headers. Initialize the Vorbis     packet->PCM decoder. */  vorbis_synthesis_init(&vd,&vi); /* central decode state */  vorbis_block_init(&vd,&vb);     /* local state for most of the decode				     so multiple block decodes can				     proceed in parallel.  We could init				     multiple vorbis_block structures				     for vd here */    mp3data->stereo = vi.channels;  mp3data->samplerate = vi.rate;  mp3data->bitrate = 0; //ov_bitrate_instant(&vf);  mp3data->nsamp=MAX_U_32_NUM;    return 0;}

//.........这里部分代码省略.........				ogg_stream_pagein(&data->vstream, &data->page);			}#endif			stream_start = 1;			break;		}		ogg_stream_init(&test, ogg_page_serialno(&data->page));		ogg_stream_pagein(&test, &data->page);		// initial codec headers		while (ogg_stream_packetout(&test, &packet) == 1) {#ifdef USE_THEORA			if (theora_decode_header(&data->tinfo, &data->tcomment, &packet) >= 0) {				memcpy(&data->vstream, &test, sizeof(test));				++num_theora;			} else#endif			if (!vorbis_synthesis_headerin(&data->vinfo, &data->vcomment, &packet)) {				memcpy(&data->astream, &test, sizeof(test));				++num_vorbis;			} else {				ogg_stream_clear(&test);			}		}	}	data->audio = num_vorbis;#ifdef USE_THEORA	data->video = num_theora;#endif	// remainint codec headers	while ((num_vorbis && num_vorbis < 3)#ifdef USE_THEORA	  || (num_theora && num_theora < 3) ) {		// are we in the theora page ?		while (num_theora && num_theora < 3 &&		  (ret = ogg_stream_packetout(&data->vstream, &packet))) {			if (ret < 0) {				return -1;			}			if (theora_decode_header(&data->tinfo, &data->tcomment, &packet)) {				return -1;			}			++num_theora;		}#else	  ) {#endif		// are we in the vorbis page ?		while (num_vorbis && num_vorbis < 3 && 		  (ret = ogg_stream_packetout(&data->astream, &packet))) {			if (ret < 0) {				return -1;			}			if (vorbis_synthesis_headerin(&data->vinfo, &data->vcomment, &packet)) {				return -1;							}			++num_vorbis;		}		if (OggGetNextPage(&data->page, &data->sync, f)) {				break;		}		if (num_vorbis) {			ogg_stream_pagein(&data->astream, &data->page);		}#ifdef USE_THEORA		if (num_theora) {			ogg_stream_pagein(&data->vstream, &data->page);		}#endif	}	if (num_vorbis) {		vorbis_synthesis_init(&data->vdsp, &data->vinfo);		vorbis_block_init(&data->vdsp, &data->vblock);	} else {    	vorbis_info_clear(&data->vinfo);    	vorbis_comment_clear(&data->vcomment);	}#ifdef USE_THEORA	if (num_theora) {		theora_decode_init(&data->tstate, &data->tinfo);		data->tstate.internal_encode = NULL;  // needed for a bug in libtheora (fixed in next release)	} else {    	theora_info_clear(&data->tinfo);    	theora_comment_clear(&data->tcomment);	}	return !(num_vorbis || num_theora);#else	return !num_vorbis;#endif}

//.........这里部分代码省略.........	int result;	char **ptr;	char *buffer;	struct vorbis_desc *tmp = (struct vorbis_desc *)s->_private;	tmp->writing = 0;	ogg_sync_init(&tmp->oy);	buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);	bytes = fread(buffer, 1, BLOCK_SIZE, s->f);	ogg_sync_wrote(&tmp->oy, bytes);	result = ogg_sync_pageout(&tmp->oy, &tmp->og);	if (result != 1) {		if(bytes < BLOCK_SIZE) {			ast_log(LOG_ERROR, "Run out of data.../n");		} else {			ast_log(LOG_ERROR, "Input does not appear to be an Ogg bitstream./n");		}		ogg_sync_clear(&tmp->oy);		return -1;	}		ogg_stream_init(&tmp->os, ogg_page_serialno(&tmp->og));	vorbis_info_init(&tmp->vi);	vorbis_comment_init(&tmp->vc);	if (ogg_stream_pagein(&tmp->os, &tmp->og) < 0) { 		ast_log(LOG_ERROR, "Error reading first page of Ogg bitstream data./n");error:		ogg_stream_clear(&tmp->os);		vorbis_comment_clear(&tmp->vc);		vorbis_info_clear(&tmp->vi);		ogg_sync_clear(&tmp->oy);		return -1;	}		if (ogg_stream_packetout(&tmp->os, &tmp->op) != 1) { 		ast_log(LOG_ERROR, "Error reading initial header packet./n");		goto error;	}		if (vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op) < 0) { 		ast_log(LOG_ERROR, "This Ogg bitstream does not contain Vorbis audio data./n");		goto error;	}		for (i = 0; i < 2 ; ) {		while (i < 2) {			result = ogg_sync_pageout(&tmp->oy, &tmp->og);			if (result == 0)				break;			if (result == 1) {				ogg_stream_pagein(&tmp->os, &tmp->og);				while(i < 2) {					result = ogg_stream_packetout(&tmp->os,&tmp->op);					if(result == 0)						break;					if(result < 0) {						ast_log(LOG_ERROR, "Corrupt secondary header.  Exiting./n");						goto error;					}					vorbis_synthesis_headerin(&tmp->vi, &tmp->vc, &tmp->op);					i++;				}			}		}		buffer = ogg_sync_buffer(&tmp->oy, BLOCK_SIZE);		bytes = fread(buffer, 1, BLOCK_SIZE, s->f);		if (bytes == 0 && i < 2) {			ast_log(LOG_ERROR, "End of file before finding all Vorbis headers!/n");			goto error;		}		ogg_sync_wrote(&tmp->oy, bytes);	}		for (ptr = tmp->vc.user_comments; *ptr; ptr++)		ast_log(LOG_DEBUG, "OGG/Vorbis comment: %s/n", *ptr);	ast_log(LOG_DEBUG, "OGG/Vorbis bitstream is %d channel, %ldHz/n", tmp->vi.channels, tmp->vi.rate);	ast_log(LOG_DEBUG, "OGG/Vorbis file encoded by: %s/n", tmp->vc.vendor);	if (tmp->vi.channels != 1) {		ast_log(LOG_ERROR, "Only monophonic OGG/Vorbis files are currently supported!/n");		goto error;	}		if (tmp->vi.rate != DEFAULT_SAMPLE_RATE) {		ast_log(LOG_ERROR, "Only 8000Hz OGG/Vorbis files are currently supported!/n");		vorbis_block_clear(&tmp->vb);		vorbis_dsp_clear(&tmp->vd);		goto error;	}		vorbis_synthesis_init(&tmp->vd, &tmp->vi);	vorbis_block_init(&tmp->vd, &tmp->vb);	return 0;}