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

static voidvorbis_dec_finalize (GObject * object){  /* Release any possibly allocated libvorbis data.   * _clear functions can safely be called multiple times   */  GstVorbisDec *vd = GST_VORBIS_DEC (object);  vorbis_block_clear (&vd->vb);  vorbis_dsp_clear (&vd->vd);  vorbis_comment_clear (&vd->vc);  vorbis_info_clear (&vd->vi);  G_OBJECT_CLASS (parent_class)->finalize (object);}

/*------------------------------------------------------------------------------ *  Close the encoding session *----------------------------------------------------------------------------*/voidVorbisLibEncoder :: close ( void )                    throw ( Exception ){    if ( isOpen() ) {        flush();        ogg_stream_clear( &oggStreamState);        vorbis_block_clear( &vorbisBlock);        vorbis_dsp_clear( &vorbisDspState);        vorbis_comment_clear( &vorbisComment);        vorbis_info_clear( &vorbisInfo);        encoderOpen = false;    }}

static int oggvorbis_encode_close(AVCodecContext *avccontext) {    OggVorbisContext *context = avccontext->priv_data ;/*  ogg_packet op ; */    vorbis_analysis_wrote(&context->vd, 0) ; /* notify vorbisenc this is EOF */    vorbis_block_clear(&context->vb);    vorbis_dsp_clear(&context->vd);    vorbis_info_clear(&context->vi);    av_freep(&avccontext->coded_frame);    av_freep(&avccontext->extradata);    return 0 ;}

static void ogg_decend(SMIXTRACK trk) {	__OV	*ov;	ov = (__OV *)trk->snd;	if (ov) {		ogg_stream_clear(&ov->os);		vorbis_block_clear(&ov->vb);		vorbis_dsp_clear(&ov->vd);		vorbis_comment_clear(&ov->vc);		vorbis_info_clear(&ov->vi);		ogg_sync_clear(&ov->oy);		_MFREE(ov);	}}

static void free_vorbis(FEED *feed) {	VORBIS_FEED *vfeed;	if (feed == NULL) return;	vfeed = (VORBIS_FEED *)feed;	if (vfeed->base.init) {		vorbis_block_clear(&(vfeed->vb));		vorbis_dsp_clear(&(vfeed->vd));		vorbis_comment_clear(&(vfeed->vc));		vorbis_info_clear(&(vfeed->vi));		ogg_stream_clear(&(vfeed->os));		ogg_sync_clear(&(vfeed->oy));		}	free_feed(feed);	return;	}

VorbisWriter::~VorbisWriter() {	if (file.isOpen()) {		debug("WARNING: VorbisWriter::~VorbisWriter(): File has not been closed, closing it now");		close();	}	if (pd) {		ogg_stream_clear(&pd->os);		vorbis_block_clear(&pd->vb);		vorbis_dsp_clear(&pd->vd);		vorbis_comment_clear(&pd->vc);		vorbis_info_clear(&pd->vi);		delete pd;	}}

int lame_encode_ogg_finish(lame_global_flags *gfp,			  char *mp3buf, int mp3buf_size){  int eos=0,bytes=0;  vorbis_analysis_wrote(&vd2,0);  while(vorbis_analysis_blockout(&vd2,&vb2)==1){        /* analysis */    vorbis_analysis(&vb2,&op2);      /* weld the packet into the bitstream */      ogg_stream_packetin(&os2,&op2);      /* write out pages (if any) */      while(!eos){	int result=ogg_stream_pageout(&os2,&og2);	if(result==0)break;	/* check if mp3buffer is big enough for the output */	bytes += og2.header_len + og2.body_len;	if (bytes > mp3buf_size && mp3buf_size>0)	  return -5;		memcpy(mp3buf,og2.header,og2.header_len);	memcpy(mp3buf+og2.header_len,og2.body,og2.body_len);	/* this could be set above, but for illustrative purposes, I do	   it here (to show that vorbis does know where the stream ends) */	if(ogg_page_eos(&og2))eos=1;      }    }  /* clean up and exit.  vorbis_info_clear() must be called last */  ogg_stream_clear(&os2);  vorbis_block_clear(&vb2);  vorbis_dsp_clear(&vd2);    /* ogg_page and ogg_packet structs always point to storage in     libvorbis.  They're never freed or manipulated directly */  return bytes;}

void VideoStreamPlaybackTheora::clear() {	if (!file)		return;	if (vorbis_p) {		ogg_stream_clear(&vo);		if (vorbis_p >= 3) {			vorbis_block_clear(&vb);			vorbis_dsp_clear(&vd);		};		vorbis_comment_clear(&vc);		vorbis_info_clear(&vi);		vorbis_p = 0;	}	if (theora_p) {		ogg_stream_clear(&to);		th_decode_free(td);		th_comment_clear(&tc);		th_info_clear(&ti);		theora_p = 0;	}	ogg_sync_clear(&oy);#ifdef THEORA_USE_THREAD_STREAMING	thread_exit = true;	thread_sem->post(); //just in case	Thread::wait_to_finish(thread);	memdelete(thread);	thread = NULL;	ring_buffer.clear();#endif	//file_name = "";	theora_p = 0;	vorbis_p = 0;	videobuf_ready = 0;	frames_pending = 0;	videobuf_time = 0;	theora_eos = false;	vorbis_eos = false;	if (file) {		memdelete(file);	}	file = NULL;	playing = false;};

static int tc_vorbis_stop(TCModuleInstance *self){    VorbisPrivateData *pd = NULL;    TC_MODULE_SELF_CHECK(self, "stop");    pd = self->userdata;    vorbis_block_clear(&pd->vb);    vorbis_dsp_clear(&pd->vd);    vorbis_comment_clear(&pd->vc);    vorbis_info_clear(&pd->vi);    tc_ogg_del_extradata(&pd->xdata);    return TC_OK;}

/***************************************************************************** * CloseDecoder: vorbis decoder destruction *****************************************************************************/static void CloseDecoder( vlc_object_t *p_this ){    decoder_t *p_dec = (decoder_t *)p_this;    decoder_sys_t *p_sys = p_dec->p_sys;    if( !p_sys->b_packetizer && p_sys->b_has_headers )    {        vorbis_block_clear( &p_sys->vb );        vorbis_dsp_clear( &p_sys->vd );    }    vorbis_comment_clear( &p_sys->vc );    vorbis_info_clear( &p_sys->vi );  /* must be called last */    free( p_sys );}

static gbooleanvorbis_dec_stop (GstAudioDecoder * dec){  GstVorbisDec *vd = GST_VORBIS_DEC (dec);  GST_DEBUG_OBJECT (dec, "stop");  vd->initialized = FALSE;#ifndef USE_TREMOLO  vorbis_block_clear (&vd->vb);#endif  vorbis_dsp_clear (&vd->vd);  vorbis_comment_clear (&vd->vc);  vorbis_info_clear (&vd->vi);  return TRUE;}

/*********************************************************************** * Close *********************************************************************** * **********************************************************************/void encvorbisClose( hb_work_object_t * w ){    hb_work_private_t * pv = w->private_data;    vorbis_block_clear( &pv->vb );    vorbis_dsp_clear( &pv->vd );    vorbis_comment_clear( &pv->vc );    vorbis_info_clear( &pv->vi );    if (pv->list)        hb_list_empty( &pv->list );    free( pv->buf );    free( pv );    w->private_data = NULL;}

static void vorbis_close(void){    vorbis_write_real (NULL, 0); /* signal end of file */    while (ogg_stream_flush (& os, & og))    {        write_output (og.header, og.header_len);        write_output (og.body, og.body_len);    }    ogg_stream_clear(&os);    vorbis_block_clear(&vb);    vorbis_dsp_clear(&vd);    vorbis_info_clear(&vi);}

static GstStateChangeReturnvorbis_dec_change_state (GstElement * element, GstStateChange transition){  GstVorbisDec *vd = GST_VORBIS_DEC (element);  GstStateChangeReturn res;  switch (transition) {    case GST_STATE_CHANGE_NULL_TO_READY:      break;    case GST_STATE_CHANGE_READY_TO_PAUSED:      vorbis_info_init (&vd->vi);      vorbis_comment_init (&vd->vc);      vd->initialized = FALSE;      gst_vorbis_dec_reset (vd);      break;    case GST_STATE_CHANGE_PAUSED_TO_PLAYING:      break;    default:      break;  }  res = parent_class->change_state (element, transition);  switch (transition) {    case GST_STATE_CHANGE_PLAYING_TO_PAUSED:      break;    case GST_STATE_CHANGE_PAUSED_TO_READY:      GST_DEBUG_OBJECT (vd, "PAUSED -> READY, clearing vorbis structures");      vd->initialized = FALSE;#ifndef USE_TREMOLO      vorbis_block_clear (&vd->vb);#endif      vorbis_dsp_clear (&vd->vd);      vorbis_comment_clear (&vd->vc);      vorbis_info_clear (&vd->vi);      gst_vorbis_dec_reset (vd);      break;    case GST_STATE_CHANGE_READY_TO_NULL:      break;    default:      break;  }  return res;}

	void OggVorbisEncoder::close()	{		if (mClosed)			return;		// Mark end of data and flush any remaining data in the buffers		vorbis_analysis_wrote(&mVorbisState, 0);		writeBlocks();		flush();		ogg_stream_clear(&mOggState);		vorbis_block_clear(&mVorbisBlock);		vorbis_dsp_clear(&mVorbisState);		vorbis_info_clear(&mVorbisInfo);		mClosed = true;	}

void SoftVorbis::onReset() {    mInputBufferCount = 0;    mNumFramesOutput = 0;    if (mState != NULL) {        vorbis_dsp_clear(mState);        delete mState;        mState = NULL;    }    if (mVi != NULL) {        vorbis_info_clear(mVi);        delete mVi;        mVi = NULL;    }    mOutputPortSettingsChange = NONE;}

void Free(void *ctx){  ogg_context *context = (ogg_context *)ctx;  if (!context)    return;  /* clean up and exit.  vorbis_info_clear() must be called last */  if (context->inited)  {    ogg_stream_clear(&context->oggStreamState);    vorbis_block_clear(&context->vorbisBlock);    vorbis_dsp_clear(&context->vorbisDspState);  }  vorbis_info_clear(&context->vorbisInfo);  return;}

/** The Deinitialization function   */OMX_ERRORTYPE omx_vorbisdec_component_Deinit(OMX_COMPONENTTYPE *openmaxStandComp) {  omx_vorbisdec_component_PrivateType* omx_vorbisdec_component_Private = openmaxStandComp->pComponentPrivate;  OMX_ERRORTYPE err = OMX_ErrorNone;  free(omx_vorbisdec_component_Private->internalOutputBuffer);  omx_vorbisdec_component_Private->internalOutputBuffer = NULL;    /** reset the vorbis decoder related parameters */  ogg_stream_clear(&omx_vorbisdec_component_Private->os);  vorbis_block_clear(&omx_vorbisdec_component_Private->vb);  vorbis_dsp_clear(&omx_vorbisdec_component_Private->vd);  vorbis_comment_clear(&omx_vorbisdec_component_Private->vc);  vorbis_info_clear(&omx_vorbisdec_component_Private->vi);  ogg_sync_clear(&omx_vorbisdec_component_Private->oy);                                                                                                                               return err;}

void SoundFileWriterOgg::close(){    if (m_file.is_open())    {        // Submit an empty packet to mark the end of stream        vorbis_analysis_wrote(&m_state, 0);        flushBlocks();        // Close the file        m_file.close();    }    // Clear all the ogg/vorbis structures    ogg_stream_clear(&m_ogg);    vorbis_dsp_clear(&m_state);    vorbis_info_clear(&m_vorbis);}

DEFINE_FINALIZE() {	if ( jl::HostRuntime::getJLRuntime( fop->runtime() ).skipCleanup() )		return;	Private *pv = static_cast<Private*>(JL_GetPrivateFromFinalize(obj));	if ( pv != NULL ) {		vorbis_dsp_clear(&pv->vds);		vorbis_info_clear(&pv->vi);		vorbis_block_clear(&pv->vb);				ogg_stream_clear(&pv->oss);		JL_freeop(fop, pv);		//js_free(pv);	}}

static gbooleangst_vorbis_enc_stop (GstAudioEncoder * enc){  GstVorbisEnc *vorbisenc = GST_VORBISENC (enc);  GST_DEBUG_OBJECT (enc, "stop");  vorbis_block_clear (&vorbisenc->vb);  vorbis_dsp_clear (&vorbisenc->vd);  vorbis_info_clear (&vorbisenc->vi);  g_free (vorbisenc->last_message);  vorbisenc->last_message = NULL;  gst_tag_list_unref (vorbisenc->tags);  vorbisenc->tags = NULL;  gst_tag_setter_reset_tags (GST_TAG_SETTER (enc));  return TRUE;}

void VorbisWriter::close() {  if(fp == NULL) {    return;  }  fclose(fp);  fp = NULL;  if(is_setup) {    ogg_stream_clear(&os);    vorbis_block_clear(&vb);    vorbis_dsp_clear(&vd);    vorbis_comment_clear(&vc);    vorbis_info_clear(&vi);  }  is_setup = false;}

void OggFree(OggData *data){	if (data->audio) {		ogg_stream_clear(&data->astream);		vorbis_block_clear(&data->vblock);		vorbis_dsp_clear(&data->vdsp);		vorbis_comment_clear(&data->vcomment);		vorbis_info_clear(&data->vinfo);	}#ifdef USE_THEORA	if (data->video) {		ogg_stream_clear(&data->vstream);		theora_comment_clear(&data->tcomment);		theora_info_clear(&data->tinfo);		theora_clear(&data->tstate);	}#endif	ogg_sync_clear(&data->sync);}

void OggDec::Clear_ogg(){	ogg_sync_clear(&oy);	ogg_stream_clear(&os);	vorbis_block_clear(&vb);	vorbis_dsp_clear(&vd);	vorbis_comment_clear(&vc);	vorbis_info_clear(&vi);	bWaveGet = FALSE;	bLoop = FALSE;	decStep = 0;	eos = 0;	if(leakSize){		free(leak_mem);		leak_mem = NULL;		leakSize = 0;		allocMemSize = 0;	}}

int FileVorbis::close_file(){	if(fd)	{		if(wr)		{			vorbis_analysis_wrote(&vd, 0);			FLUSH_VORBIS			ogg_stream_clear(&os);			vorbis_block_clear(&vb);			vorbis_dsp_clear(&vd);			vorbis_comment_clear(&vc);			vorbis_info_clear(&vi);			fclose(fd);		}				if(rd)		{// This also closes the file handle.			ov_clear(&vf);		}		fd = 0;	}	if(pcm_history)	{		for(int i = 0; i < asset->channels; i++)			delete [] pcm_history[i];		delete [] pcm_history;	}	if(pcm_history_float)	{		for(int i = 0; i < asset->channels; i++)			delete [] pcm_history_float[i];		delete [] pcm_history_float;	}	reset_parameters();	FileBase::close_file();	return 0;}

static boolvorbis_encoder_pre_tag(struct encoder *_encoder, G_GNUC_UNUSED GError **error){	struct vorbis_encoder *encoder = (struct vorbis_encoder *)_encoder;	vorbis_analysis_wrote(&encoder->vd, 0);	vorbis_encoder_blockout(encoder);	/* reinitialize vorbis_dsp_state and vorbis_block to reset the	   end-of-stream marker */	vorbis_block_clear(&encoder->vb);	vorbis_dsp_clear(&encoder->vd);	vorbis_analysis_init(&encoder->vd, &encoder->vi);	vorbis_block_init(&encoder->vd, &encoder->vb);	ogg_stream_reset(&encoder->os);	encoder->flush = true;	return true;}

static GstFlowReturngst_vorbis_enc_clear (GstVorbisEnc * vorbisenc){  GstFlowReturn ret = GST_FLOW_OK;  if (vorbisenc->setup) {    vorbis_analysis_wrote (&vorbisenc->vd, 0);    ret = gst_vorbis_enc_output_buffers (vorbisenc);    /* marked EOS to encoder, recreate if needed */    vorbisenc->setup = FALSE;  }  /* clean up and exit.  vorbis_info_clear() must be called last */  vorbis_block_clear (&vorbisenc->vb);  vorbis_dsp_clear (&vorbisenc->vd);  vorbis_info_clear (&vorbisenc->vi);  return ret;}

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