static void
vorbis_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
*----------------------------------------------------------------------------*/
void
VorbisLibEncoder :: 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 gboolean
vorbis_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 GstStateChangeReturn
gst_vorbis_enc_change_state (GstElement * element, GstStateChange transition)
{
GstVorbisEnc *vorbisenc = GST_VORBISENC (element);
GstStateChangeReturn res;
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
vorbisenc->tags = gst_tag_list_new ();
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
vorbisenc->setup = FALSE;
vorbisenc->next_discont = FALSE;
vorbisenc->header_sent = FALSE;
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
default:
break;
}
res = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
vorbis_block_clear (&vorbisenc->vb);
vorbis_dsp_clear (&vorbisenc->vd);
vorbis_info_clear (&vorbisenc->vi);
g_free (vorbisenc->last_message);
vorbisenc->last_message = NULL;
if (vorbisenc->srccaps) {
gst_caps_unref (vorbisenc->srccaps);
vorbisenc->srccaps = NULL;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
gst_tag_list_free (vorbisenc->tags);
vorbisenc->tags = NULL;
default:
break;
}
return res;
}
static GstStateChangeReturn
vorbis_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 gboolean
gst_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;
}
static gboolean
gst_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_free (vorbisenc->tags);
vorbisenc->tags = NULL;
g_slist_foreach (vorbisenc->headers, (GFunc) gst_buffer_unref, NULL);
vorbisenc->headers = NULL;
return TRUE;
}
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 bool
vorbis_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 GstFlowReturn
gst_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;
}