/*!
* \brief Close a OGG/Vorbis filestream.
* \param s A OGG/Vorbis filestream.
*/
static void ogg_vorbis_close(struct cw_filestream *s)
{
if (cw_mutex_lock(&ogg_vorbis_lock)) {
cw_log(LOG_WARNING, "Unable to lock ogg_vorbis list\n");
return;
}
glistcnt--;
cw_mutex_unlock(&ogg_vorbis_lock);
cw_update_use_count();
if (s->writing) {
/* Tell the Vorbis encoder that the stream is finished
* and write out the rest of the data */
vorbis_analysis_wrote(&s->vd, 0);
write_stream(s);
}
ogg_stream_clear(&s->os);
vorbis_block_clear(&s->vb);
vorbis_dsp_clear(&s->vd);
vorbis_comment_clear(&s->vc);
vorbis_info_clear(&s->vi);
if (s->writing) {
ogg_sync_clear(&s->oy);
}
fclose(s->fp);
free(s);
}
static void ogg_apply_client (format_plugin_t *plugin, client_t *client)
{
ogg_state_t *state = plugin->_state;
state->mount = NULL;
ogg_sync_clear (&state->oy);
if (client == NULL)
return;
plugin->parser = client->parser;
if (plugin->parser)
{
const char *s = httpp_getvar (plugin->parser, "content-type");
if (s==NULL || strcmp (s, "application/x-ogg") == 0)
httpp_setvar (plugin->parser, "content-type", "application/ogg");
s = httpp_getvar (plugin->parser, "content-type");
if (s)
plugin->contenttype = strdup (s);
}
ogg_sync_init (&state->oy);
state->mount = plugin->mount;
state->bos_end = &state->header_pages;
}
/*!
* \brief Close a OGG/Speex filestream.
* \param fs A OGG/Speex filestream.
*/
static void ogg_speex_close(struct ast_filestream *fs)
{
struct speex_desc *s = (struct speex_desc *)fs->_private;
ogg_stream_clear(&s->os);
ogg_sync_clear(&s->oy);
}
int ogg_sync_destroy(ogg_sync_state *oy){
if(oy){
ogg_sync_clear(oy);
_ogg_free(oy);
}
return(0);
}
void Cin_OGM_Shutdown() {
#ifdef USE_CIN_XVID
int status;
status = shutdown_xvid();
if (status)
Com_Printf("[Xvid]Decore RELEASE problem, return value %d\n", status);
#endif
#ifdef USE_CIN_THEORA
theora_clear(&g_ogm.th_state);
theora_comment_clear(&g_ogm.th_comment);
theora_info_clear(&g_ogm.th_info);
#endif
if(g_ogm.outputBuffer) free(g_ogm.outputBuffer);
g_ogm.outputBuffer = NULL;
vorbis_dsp_clear(&g_ogm.vd);
vorbis_comment_clear(&g_ogm.vc);
vorbis_info_clear(&g_ogm.vi); /* must be called last (comment from vorbis example code) */
ogg_stream_clear(&g_ogm.os_audio);
ogg_stream_clear(&g_ogm.os_video);
ogg_sync_clear(&g_ogm.oy);
FS_FCloseFile(g_ogm.ogmFile);
g_ogm.ogmFile = 0;
}
void format_vorbis_free_plugin(format_plugin_t *self)
{
int i;
vstate_t *state = (vstate_t *)self->_state;
/* free memory associated with this plugin instance */
/* free state memory */
ogg_sync_clear(&state->oy);
ogg_stream_clear(&state->os);
vorbis_comment_clear(&state->vc);
vorbis_info_clear(&state->vi);
for (i = 0; i < MAX_HEADER_PAGES; i++) {
if (state->headbuf[i]) {
refbuf_release(state->headbuf[i]);
state->headbuf[i] = NULL;
}
}
free(state);
/* free the plugin instance */
free(self);
}
void VideoStreamTheora::clear() {
if (file_name == "")
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);
file_name = "";
theora_p = 0;
vorbis_p = 0;
videobuf_ready = 0;
frames_pending = 0;
videobuf_time = 0;
playing = false;
};
/* clear out the OggVorbis_File struct */
int ov_clear(OggVorbis_File *vf){
if(vf){
vorbis_block_clear(&vf->vb);
vorbis_dsp_clear(&vf->vd);
ogg_stream_clear(&vf->os);
if(vf->vi && vf->links){
int i;
for(i=0;i<vf->links;i++){
vorbis_info_clear(vf->vi+i);
vorbis_comment_clear(vf->vc+i);
}
_ogg_free(vf->vi);
_ogg_free(vf->vc);
}
if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
if(vf->serialnos)_ogg_free(vf->serialnos);
if(vf->offsets)_ogg_free(vf->offsets);
ogg_sync_clear(&vf->oy);
if(vf->datasource)(vf->callbacks.close_func)(vf->datasource);
memset(vf,0,sizeof(*vf));
}
#ifdef DEBUG_LEAKS
_VDBG_dump();
#endif
return(0);
}
static int
ogg_close (SF_PRIVATE *psf)
{
OGG_PRIVATE *odata = (OGG_PRIVATE *) psf->container_data ;
VORBIS_PRIVATE *vdata = (VORBIS_PRIVATE *) psf->codec_data ;
if (odata == NULL || vdata == NULL)
return 0 ;
/* Clean up this logical bitstream ; before exit we shuld see if we're
** followed by another [chained]. */
if (psf->file.mode == SFM_WRITE)
{
if (psf->write_current <= 0)
ogg_write_header (psf, 0) ;
vorbis_analysis_wrote (&vdata->vd, 0) ;
while (vorbis_analysis_blockout (&vdata->vd, &vdata->vb) == 1)
{
/* analysis, assume we want to use bitrate management */
vorbis_analysis (&vdata->vb, NULL) ;
vorbis_bitrate_addblock (&vdata->vb) ;
while (vorbis_bitrate_flushpacket (&vdata->vd, &odata->op))
{ /* weld the packet into the bitstream */
ogg_stream_packetin (&odata->os, &odata->op) ;
/* write out pages (if any) */
while (!odata->eos)
{ int result = ogg_stream_pageout (&odata->os, &odata->og) ;
if (result == 0) break ;
psf_fwrite (odata->og.header, 1, odata->og.header_len, psf) ;
psf_fwrite (odata->og.body, 1, odata->og.body_len, psf) ;
/* 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 (&odata->og)) odata->eos = 1 ;
}
}
}
}
/* ogg_page and ogg_packet structs always point to storage in
libvorbis. They are never freed or manipulated directly */
vorbis_block_clear (&vdata->vb) ;
vorbis_dsp_clear (&vdata->vd) ;
vorbis_comment_clear (&vdata->vc) ;
vorbis_info_clear (&vdata->vi) ; /* must be called last */
/* should look here to reopen if chained */
/* OK, clean up the framer */
ogg_sync_clear (&odata->oy) ;
ogg_stream_clear (&odata->os) ;
return 0 ;
} /* ogg_close */
/* clear the ogg/vorbis decoder */
static void oggamp_vorbis_sync_clear(t_oggamp *x)
{
/* OK, clean up the framer */
ogg_sync_clear(&(x->x_oy));
x->x_sync = 0;
post("oggamp~: decoder cleared");
}
static sf_count_t
vorbis_length_aux (SF_PRIVATE * psf)
{ ogg_sync_state osync ;
ogg_page page ;
sf_count_t len = 0 ;
stream_set *processors ;
processors = create_stream_set () ;
if (processors == NULL)
return 0 ; // out of memory?
ogg_sync_init (&osync) ;
while (vorbis_length_get_next_page (psf, &osync, &page))
{ stream_processor *p = find_stream_processor (processors, &page) ;
if (!p)
{ len = 0 ;
break ;
} ;
if (p->isillegal && !p->shownillegal)
{ p->shownillegal = 1 ;
/* If it's a new stream, we want to continue processing this page
** anyway to suppress additional spurious errors
*/
if (!p->isnew) continue ;
} ;
if (!p->isillegal)
{ ogg_packet packet ;
int header = 0 ;
ogg_stream_pagein (&p->ostream, &page) ;
if (p->doneheaders < 3)
header = 1 ;
while (ogg_stream_packetout (&p->ostream, &packet) > 0)
{ if (p->doneheaders < 3)
{ if (vorbis_synthesis_headerin (&p->vinfo, &p->vcomment, &packet) < 0)
continue ;
p->doneheaders ++ ;
} ;
} ;
if (!header)
{ sf_count_t gp = ogg_page_granulepos (&page) ;
if (gp > 0) p->lastgranulepos = gp ;
} ;
if (p->end)
{ vorbis_end (p, &len) ;
p->isillegal = 1 ;
} ;
} ;
} ;
ogg_sync_clear (&osync) ;
free_stream_set (processors, &len) ;
return len ;
} /* vorbis_length_aux */
static void vcedit_clear_internals(vcedit_state *state)
{
if(state->vc)
{
vorbis_comment_clear(state->vc);
free(state->vc);
state->vc=NULL;
}
if(state->os)
{
ogg_stream_clear(state->os);
free(state->os);
state->os=NULL;
}
if(state->oy)
{
ogg_sync_clear(state->oy);
free(state->oy);
state->oy=NULL;
}
if(state->vendor)
{
free(state->vendor);
state->vendor=NULL;
}
}
static void vcedit_clear_internals(vcedit_state *state)
{
if(state->vc)
{
vorbis_comment_clear(state->vc);
free(state->vc);
}
if(state->os)
{
ogg_stream_clear(state->os);
free(state->os);
}
if(state->oy)
{
ogg_sync_clear(state->oy);
free(state->oy);
}
if(state->vendor)
free(state->vendor);
if(state->mainbuf)
free(state->mainbuf);
if(state->bookbuf)
free(state->bookbuf);
if(state->vi) {
vorbis_info_clear(state->vi);
free(state->vi);
}
memset(state, 0, sizeof(*state));
}
static struct spx_data *spx_open_internal (struct io_stream *stream)
{
struct spx_data *data;
SpeexStereoState stereo = SPEEX_STEREO_STATE_INIT;
data = (struct spx_data *)xmalloc (sizeof(struct spx_data));
decoder_error_init (&data->error);
data->stream = stream;
data->st = NULL;
data->stereo = stereo;
data->header = NULL;
data->output = NULL;
data->comment_packet = NULL;
data->bitrate = -1;
ogg_sync_init (&data->oy);
speex_bits_init (&data->bits);
if (!read_speex_header(data)) {
ogg_sync_clear (&data->oy);
speex_bits_destroy (&data->bits);
data->ok = 0;
}
else
data->ok = 1;
return data;
}
void DGVideo::unload() {
if (_isLoaded) {
_isLoaded = false;
_state = DGVideoInitial;
_theoraInfo->videobuf_ready = 0;
_theoraInfo->videobuf_granulepos -= 1;
_theoraInfo->videobuf_time = 0;
if (_theoraInfo->theora_p) {
// Rewind and reset
fseek(_handle, (long)_theoraInfo->bos * 8, SEEK_SET);
ogg_stream_reset(&_theoraInfo->to);
ogg_stream_clear(&_theoraInfo->to);
theora_clear(&_theoraInfo->td);
theora_comment_clear(&_theoraInfo->tc);
theora_info_clear(&_theoraInfo->ti);
}
ogg_sync_clear(&_theoraInfo->oy);
_theoraInfo->theora_p = 0;
free(_currentFrame.data);
fclose(_handle);
}
}
static PyObject * py_ogg_ogg_sync_clear(PyObject *self, PyObject *args) {
int c_out;
int size;
ogg_sync_state * oy;
PyArg_ParseTuple(args, "s#", &oy, &size);
c_out = ogg_sync_clear(oy);
return Py_BuildValue("i", c_out);
};
static int ogg_read_close(AVFormatContext *avfcontext) {
OggContext *context = avfcontext->priv_data ;
ogg_stream_clear(&context->os) ;
ogg_sync_clear(&context->oy) ;
return 0 ;
}
int main()
{
ogg_sync_state oy;
ogg_stream_state os;
int init=0;
ogg_packet op;
kate_state k;
kate_info ki;
kate_comment kc;
const kate_event *ev;
/* for the benefit of windows, which mangles data otherwise */
set_binary_file(stdin);
/* we initialize ogg and kate info/comment structures */
ogg_sync_init(&oy);
kate_info_init(&ki);
kate_comment_init(&kc);
/*
First, read the headers, which must appear first in a Kate stream. When
kate_decode_header returns a positive number, all headers have been seen
and we're ready to decode data.
*/
do {
get_packet(&oy,&os,&init,&op);
} while (kate_ogg_decode_headerin(&ki,&kc,&op)==0);
/*
We now have all the information we need from the headers, so we can
initialize kate for decoding
*/
kate_decode_init(&k,&ki);
/*
We can now read data, until kate_decode_packetin returns a positive
number, signaling the end of the stream
*/
while (1) {
if (get_packet(&oy,&os,&init,&op)) break;
if (kate_ogg_decode_packetin(&k,&op)>0) break;
/* we may have an event (eg, text) */
if (kate_decode_eventout(&k,&ev)==0) {
printf("Kate stream has text: %s\n",ev->text);
}
}
/* That's it, we can now cleanup */
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
kate_clear(&k);
kate_info_clear(&ki);
kate_comment_clear(&kc);
return 0;
}
flac_header_extractor_c::~flac_header_extractor_c() {
FLAC__stream_decoder_reset(decoder);
FLAC__stream_decoder_delete(decoder);
ogg_sync_clear(&oy);
ogg_stream_clear(&os);
delete file;
}
static int
ogg_close (SF_PRIVATE *psf)
{ OGG_PRIVATE* odata = psf->container_data ;
ogg_sync_clear (&odata->osync) ;
ogg_stream_clear (&odata->ostream) ;
return 0 ;
} /* ogg_close */
int player_example_close_input(player_example *player) {
int ret;
if (player == NULL) return -1;
if ((player->input == stdin) || (player->input == NULL)) return -1;
ret = fclose(player->input);
player->input = NULL;
ogg_sync_clear(&player->oy);
if (ret != 0) return -1;
return 0;
}
void TheoraClose()
{
ogg_stream_clear ( &m_StreamState );
theora_clear ( &m_State );
theora_comment_clear ( &m_Comment );
theora_info_clear ( &m_Info );
ogg_sync_clear ( &m_SyncState );
fclose( m_File );
}
/*
* Class: org_tritonus_lowlevel_ogg_SyncState
* Method: clear
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_org_tritonus_lowlevel_ogg_SyncState_clear
(JNIEnv* env, jobject obj)
{
ogg_sync_state* handle;
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_ogg_SyncState_clear(): begin\n"); }
handle = getHandle(env, obj);
ogg_sync_clear(handle);
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_ogg_SyncState_clear(): end\n"); }
}
OggReader::~OggReader()
{
TRACE("OggReader::~OggReader\n");
serialno_OggTrack_map::iterator i = fTracks.begin();
while (i != fTracks.end()) {
serialno_OggTrack_map::iterator j = i;
i++;
delete j->second;
}
ogg_sync_clear(&fSync);
}
static void
gst_ogg_avi_parse_finalize (GObject * object)
{
GstOggAviParse *ogg = GST_OGG_AVI_PARSE (object);
GST_LOG_OBJECT (ogg, "Disposing of object %p", ogg);
ogg_sync_clear (&ogg->sync);
ogg_stream_clear (&ogg->stream);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
int
mm_close(mm_file *mf)
{
assert(mf);
if (mf->file) {
fclose(mf->file);
mf->file = NULL;
}
if (mf->audio) {
ogg_stream_destroy(mf->audio);
mf->audio = NULL;
}
if (mf->video) {
ogg_stream_destroy(mf->video);
mf->video = NULL;
}
if (mf->video_ctx) {
theora_clear(mf->video_ctx);
free(mf->video_ctx);
mf->video_ctx = NULL;
}
if (mf->video_info) {
theora_info_clear(mf->video_info);
free(mf->video_info);
mf->video_info = NULL;
}
if (mf->audio_blk) {
vorbis_block_clear(mf->audio_blk);
free(mf->audio_blk);
mf->audio_blk = NULL;
}
if (mf->audio_ctx) {
vorbis_dsp_clear(mf->audio_ctx);
free(mf->audio_ctx);
mf->audio_ctx = NULL;
}
if (mf->audio_info) {
vorbis_info_clear(mf->audio_info);
free(mf->audio_info);
mf->audio_info = NULL;
}
ogg_sync_clear(&mf->sync);
return 0;
}
static void format_ogg_free_plugin (format_plugin_t *plugin, client_t *client)
{
ogg_state_t *state = plugin->_state;
/* free memory associated with this plugin instance */
free_ogg_codecs (state);
free (state->artist);
free (state->title);
ogg_sync_clear (&state->oy);
free (state);
}
static void close_module(input_module_t *mod)
{
if (mod == NULL) return;
if (mod->internal)
{
playlist_state_t *pl = (playlist_state_t *)mod->internal;
pl->clear(pl->data);
ogg_sync_clear(&pl->oy);
free(pl);
}
free(mod);
}
bool Oggeyman::shutdown() {
// shutdown in the reverse order of intialization
theora_clear(&theo_state);
ogg_stream_clear(&ogg_theora_stream_state);
theora_comment_clear(&theo_comment);
theora_info_clear(&theo_info);
ogg_sync_clear(&overall_sync_state);
if (infptr)
fclose(infptr);
return true;
}
static void ogg_decend(GETSND snd) {
__OV *ov;
ov = (__OV *)snd->snd;
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);
}