void pcm_convert_deinit(struct pcm_convert_state *state)
{
pcm_resample_deinit(&state->resample);
pcm_buffer_deinit(&state->format_buffer);
pcm_buffer_deinit(&state->pack_buffer);
pcm_buffer_deinit(&state->channels_buffer);
pcm_buffer_deinit(&state->byteswap_buffer);
}
void
pcm_resample_lsr_deinit(struct pcm_resample_state *state)
{
if (state->state != NULL)
state->state = src_delete(state->state);
pcm_buffer_deinit(&state->in);
pcm_buffer_deinit(&state->out);
pcm_buffer_deinit(&state->buffer);
}
static void
flac_encoder_close(struct encoder *_encoder)
{
struct flac_encoder *encoder = (struct flac_encoder *)_encoder;
FLAC__stream_encoder_delete(encoder->fse);
pcm_buffer_deinit(&encoder->buffer);
pcm_buffer_deinit(&encoder->expand_buffer);
}
static void
route_filter_close(struct filter *_filter)
{
struct route_filter *filter = (struct route_filter *)_filter;
pcm_buffer_deinit(&filter->output_buffer);
}
void audio_output_finish(struct audio_output *ao)
{
audio_output_close(ao);
assert(ao->fail_timer == NULL);
if (ao->thread != NULL) {
g_mutex_lock(ao->mutex);
ao_command(ao, AO_COMMAND_KILL);
g_mutex_unlock(ao->mutex);
g_thread_join(ao->thread);
}
if (ao->mixer != NULL)
mixer_free(ao->mixer);
ao_plugin_finish(ao->plugin, ao->data);
g_cond_free(ao->cond);
g_mutex_free(ao->mutex);
if (ao->replay_gain_filter != NULL)
filter_free(ao->replay_gain_filter);
if (ao->other_replay_gain_filter != NULL)
filter_free(ao->other_replay_gain_filter);
filter_free(ao->filter);
pcm_buffer_deinit(&ao->cross_fade_buffer);
}
static void
null_encoder_close(struct encoder *_encoder)
{
struct null_encoder *encoder = (struct null_encoder *)_encoder;
pcm_buffer_deinit(&encoder->buffer);
}
static void
volume_filter_close(struct filter *_filter)
{
struct volume_filter *filter = (struct volume_filter *)_filter;
pcm_buffer_deinit(&filter->buffer);
}
static void
replay_gain_filter_close(struct filter *_filter)
{
struct replay_gain_filter *filter =
(struct replay_gain_filter *)_filter;
pcm_buffer_deinit(&filter->buffer);
}
static void
wave_encoder_finish(struct encoder *_encoder)
{
struct wave_encoder *encoder = (struct wave_encoder *)_encoder;
pcm_buffer_deinit(&encoder->buffer);
g_free(encoder);
}
static void
normalize_filter_close(struct filter *_filter)
{
struct normalize_filter *filter = (struct normalize_filter *)_filter;
pcm_buffer_deinit(&filter->buffer);
Compressor_delete(filter->compressor);
}
void
flac_data_deinit(struct flac_data *data)
{
pcm_buffer_deinit(&data->buffer);
if (data->tag != NULL)
tag_free(data->tag);
}
void
pcm_dsd_deinit(struct pcm_dsd *dsd)
{
pcm_buffer_deinit(&dsd->buffer);
for (unsigned i = 0; i < G_N_ELEMENTS(dsd->dsd2pcm); ++i)
if (dsd->dsd2pcm[i] != NULL)
dsd2pcm_destroy(dsd->dsd2pcm[i]);
}
static void
winmm_output_close(void *data)
{
struct winmm_output *wo = data;
for (unsigned i = 0; i < G_N_ELEMENTS(wo->buffers); ++i)
pcm_buffer_deinit(&wo->buffers[i].buffer);
waveOutClose(wo->handle);
CloseHandle(wo->event);
}
static void
input_cdio_close(struct input_stream *is)
{
struct input_cdio_paranoia *i = (struct input_cdio_paranoia *)is;
pcm_buffer_deinit(&i->conv_buffer);
if (i->para)
cdio_paranoia_free(i->para);
if (i->drv)
cdio_cddap_close_no_free_cdio( i->drv);
if (i->cdio)
cdio_destroy( i->cdio );
input_stream_deinit(&i->base);
g_free(i);
}
void
ao_base_finish(struct audio_output *ao)
{
assert(!ao->open);
assert(ao->fail_timer == NULL);
assert(ao->thread == NULL);
if (ao->mixer != NULL)
mixer_free(ao->mixer);
g_cond_free(ao->cond);
g_mutex_free(ao->mutex);
if (ao->replay_gain_filter != NULL)
filter_free(ao->replay_gain_filter);
if (ao->other_replay_gain_filter != NULL)
filter_free(ao->other_replay_gain_filter);
filter_free(ao->filter);
pcm_buffer_deinit(&ao->cross_fade_buffer);
}
void
pcm_resample_fallback_deinit(struct pcm_resample_state *state)
{
pcm_buffer_deinit(&state->buffer);
}
