static void uninit(sh_audio_t *sh){
mad_decoder_t *this = sh->context;
mad_synth_finish (&this->synth);
mad_frame_finish (&this->frame);
mad_stream_finish(&this->stream);
free(sh->context);
}
void LibMadWrapper::close() noexcept
{
if (this->synth.hasValue)
{
mad_synth_finish(&this->synth.Value);
this->synth.hasValue = false;
}
if (this->frame.hasValue)
{
mad_frame_finish(&this->frame.Value);
this->frame.hasValue = false;
}
if (this->stream != nullptr)
{
mad_stream_finish(this->stream);
delete this->stream;
this->stream = nullptr;
}
if (this->mpegbuf != nullptr)
{
munmap(this->mpegbuf, this->mpeglen);
this->mpegbuf = nullptr;
this->mpeglen = 0;
}
if (this->infile != nullptr)
{
fclose(this->infile);
this->infile = nullptr;
}
}
void mad_js_close(madfile_t *mf) {
mad_synth_finish(&mf->synth);
mad_frame_finish(&mf->frame);
mad_stream_finish(&mf->stream);
free(mf->buf);
free(mf);
}
MADTranscode::~MADTranscode()
{
qDebug() << Q_FUNC_INFO;
mad_synth_finish( &synth );
mad_frame_finish( &frame );
mad_stream_finish( &stream );
}
void FreeTune() {
if (FBptr)
free(FBptr);
mad_synth_finish(&synth);
mad_frame_finish(&frame);
mad_stream_finish(&stream);
};
static void mp3_finish (mp3_s *mp3)
{
mad_synth_finish (&mp3->synth);
mad_frame_finish (&mp3->frame);
mad_stream_finish (&mp3->stream);
fclose (mp3->file);
}
static void mp_shutdown (music_player_t *music)
{
mp_player_t *mp = (mp_player_t*)music;
mad_synth_finish (&mp->Synth);
mad_frame_finish (&mp->Frame);
mad_stream_finish (&mp->Stream);
mad_header_finish (&mp->Header);
}
void Mp3Decoder::uninit(sh_audio_t *sh)
{
mad_decoder_t *mad_dec = (mad_decoder_t *) sh->context;
mad_synth_finish (&mad_dec->synth);
mad_frame_finish (&mad_dec->frame);
mad_stream_finish(&mad_dec->stream);
free(sh->context);
}
static void
deinit_mad_decoder (mp3d_prc_t * ap_prc)
{
assert (ap_prc);
mad_synth_finish (&ap_prc->synth_);
mad_frame_finish (&ap_prc->frame_);
mad_stream_finish (&ap_prc->stream_);
}
uint8_t ADM_AudiocodecMP3::endDecompress( void )
{
mad_synth_finish(Synth);
mad_frame_finish(Frame);
mad_stream_finish(Stream);
_head=_tail=0;
return 1;
}
void MadDecoder::finish()
{
mad_synth_finish(&madSynth_);
mad_frame_finish(&madFrame_);
mad_stream_finish(&madStream_);
initialized_ = false;
}
static void mp_shutdown (void)
{
mad_synth_finish (&Synth);
mad_frame_finish (&Frame);
mad_stream_finish (&Stream);
mad_header_finish (&Header);
}
RageSoundReader_MP3::~RageSoundReader_MP3()
{
mad_synth_finish( &mad->Synth );
mad_frame_finish( &mad->Frame );
mad_stream_finish( &mad->Stream );
delete mad;
}
void CodecMpeg1::FreeLibmad()
{
#ifdef HAVE_LIBMAD
mad_frame_finish(&mpeg1_mad_frame);
mad_synth_finish(&mpeg1_mad_synth);
mad_stream_finish(&mpeg1_mad_stream);
dlclose(mpeg1_mad_handle);
#endif // HAVE_LIBMAD
}
static void mp3_data_finish(struct mp3_data *data)
{
mad_synth_finish(&data->synth);
mad_frame_finish(&data->frame);
mad_stream_finish(&data->stream);
g_free(data->frame_offsets);
g_free(data->times);
}
void
mad_closeFile(mad_data *mp3_mad) {
SDL_FreeRW(mp3_mad->rw);
mad_stream_finish(&mp3_mad->stream);
mad_frame_finish(&mp3_mad->frame);
mad_synth_finish(&mp3_mad->synth);
free(mp3_mad);
}
void MP3Decoder::mp3_uninit() {
if (_isInited) {
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
_isInited = false;
}
}
static struct mp3_data *mp3_open_internal (const char *file,
const int buffered)
{
struct mp3_data *data;
data = (struct mp3_data *)xmalloc (sizeof(struct mp3_data));
data->ok = 0;
decoder_error_init (&data->error);
/* Reset information about the file */
data->freq = 0;
data->channels = 0;
data->skip_frames = 0;
data->bitrate = -1;
data->avg_bitrate = -1;
/* Open the file */
data->io_stream = io_open (file, buffered);
if (io_ok(data->io_stream)) {
data->ok = 1;
data->size = io_file_size (data->io_stream);
mad_stream_init (&data->stream);
mad_frame_init (&data->frame);
mad_synth_init (&data->synth);
if (options_get_int("Mp3IgnoreCRCErrors"))
mad_stream_options (&data->stream,
MAD_OPTION_IGNORECRC);
data->duration = count_time_internal (data);
mad_frame_mute (&data->frame);
data->stream.next_frame = NULL;
data->stream.sync = 0;
data->stream.error = MAD_ERROR_NONE;
if (io_seek(data->io_stream, SEEK_SET, 0) == (off_t)-1) {
decoder_error (&data->error, ERROR_FATAL, 0,
"seek failed");
io_close (data->io_stream);
mad_stream_finish (&data->stream);
mad_frame_finish (&data->frame);
mad_synth_finish (&data->synth);
data->ok = 0;
}
data->stream.error = MAD_ERROR_BUFLEN;
}
else {
decoder_error (&data->error, ERROR_FATAL, 0, "Can't open: %s",
io_strerror(data->io_stream));
io_close (data->io_stream);
}
return data;
}
/*****************************************************************************
* CloseFilter : deallocate data structures
*****************************************************************************/
static void CloseFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
mad_synth_finish( &p_sys->mad_synth );
mad_frame_finish( &p_sys->mad_frame );
mad_stream_finish( &p_sys->mad_stream );
free( p_sys );
}
void CMpegAudioDecoder::CloseDecoder()
{
if (m_bInitialized) {
mad_synth_finish(&m_MadSynth);
mad_frame_finish(&m_MadFrame);
mad_stream_finish(&m_MadStream);
m_bInitialized = false;
}
}
void XMp3Decomp::finishMad()
{
if (m_isInitMad)
{
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
m_isInitMad = false;
}
}
void MP3Stream::deinitStream() {
if (_state == MP3_STATE_INIT)
return;
// Deinit MAD
mad_synth_finish(&_synth);
mad_frame_finish(&_frame);
mad_stream_finish(&_stream);
_state = MP3_STATE_EOS;
}
ADM_AudiocodecMP3::~ADM_AudiocodecMP3( )
{
mad_synth_finish(Synth);
mad_frame_finish(Frame);
mad_stream_finish(Stream);
ADM_dealloc(_stream);
ADM_dealloc(_frame);
ADM_dealloc(_synth);
_synth=_synth=_stream=NULL;
}
void MAD_WRAPPER_delete( MAD_WRAPPER *mad )
{
mad_synth_finish( &mad->Synth );
mad_frame_finish( &mad->Frame );
mad_stream_finish( &mad->Stream );
delete[] mad->input_buf;
delete[] mad->output_buf;
SDL_FreeRW( mad->src );
delete mad;
}
//
// madx_deinit():
//
// Close files, free memory allocated for
// structures.
//
void madx_deinit (madx_house *mxhouse)
{
// Mad is no longer used, the structures
// that were initialized must now be
// cleared.
mad_synth_finish(&mxhouse->synth);
mad_frame_finish(&mxhouse->frame);
mad_stream_finish(&mxhouse->stream);
}
Mp3Decoder::~Mp3Decoder()
{
ExitRequested = true;
while(Decoding)
usleep(100);
mad_synth_finish(&Synth);
mad_frame_finish(&Frame);
mad_stream_finish(&Stream);
MEM2_free(ReadBuffer);
}
void
mad_closeFile(mad_data *mp3_mad)
{
mad_stream_finish(&mp3_mad->stream);
mad_frame_finish(&mp3_mad->frame);
mad_synth_finish(&mp3_mad->synth);
if (mp3_mad->freesrc) {
SDL_RWclose(mp3_mad->src);
}
SDL_free(mp3_mad);
}
bool ADM_AudiocodecMP3::resetAfterSeek( void )
{
mad_synth_finish(Synth);
mad_frame_finish(Frame);
mad_stream_finish(Stream);
mad_stream_init(Stream);
mad_frame_init(Frame);
mad_synth_init(Synth);
_head=_tail=0;
return 1;
}
static void mp3_close (void *void_data)
{
struct mp3_data *data = (struct mp3_data *)void_data;
if (data->ok) {
io_close (data->io_stream);
mad_stream_finish (&data->stream);
mad_frame_finish (&data->frame);
mad_synth_finish (&data->synth);
}
decoder_error_clear (&data->error);
free (data);
}
static void close_mad(bgav_stream_t * s)
{
mad_priv_t * priv;
priv = s->decoder_priv;
mad_synth_finish(&priv->synth);
mad_frame_finish(&priv->frame);
mad_stream_finish(&priv->stream);
bgav_bytebuffer_free(&priv->buf);
if(priv->audio_frame)
gavl_audio_frame_destroy(priv->audio_frame);
free(priv);
}
