mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-03 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

resampler: Make resampler struct implementation agnostic

Browse source 
The pa_resampler struct contains many implementation specific
structures. These create overhead and don't belong there anyways.

This patch moves the implementation specific structures out of the
pa_resampler structure.
This commit is contained in:
poljar (Damir Jelić) 2013-06-18 14:22:26 +02:00
parent 1cd6a3ad70
commit 97feeab40c
1 changed files with 136 additions and 84 deletions
Download patch file Download diff file Expand all files Collapse all files

220
src/pulsecore/resampler.c
View file

@ -78,37 +78,37 @@ struct pa_resampler {
void (*impl_update_rates)(pa_resampler *r); void (*impl_update_rates)(pa_resampler *r);
void (*impl_resample)(pa_resampler *r, const pa_memchunk *in, unsigned in_samples, pa_memchunk *out, unsigned *out_samples); void (*impl_resample)(pa_resampler *r, const pa_memchunk *in, unsigned in_samples, pa_memchunk *out, unsigned *out_samples);
void (*impl_reset)(pa_resampler *r); void (*impl_reset)(pa_resampler *r);
void *impl_data;
};
struct { /* data specific to the trivial resampler */ struct trivial_data { /* data specific to the trivial resampler */
unsigned o_counter; unsigned o_counter;
unsigned i_counter; unsigned i_counter;
} trivial; };
struct { /* data specific to the peak finder pseudo resampler */ struct peaks_data { /* data specific to the peak finder pseudo resampler */
unsigned o_counter; unsigned o_counter;
unsigned i_counter; unsigned i_counter;
float max_f[PA_CHANNELS_MAX]; float max_f[PA_CHANNELS_MAX];
int16_t max_i[PA_CHANNELS_MAX]; int16_t max_i[PA_CHANNELS_MAX];
};
} peaks;
#ifdef HAVE_LIBSAMPLERATE #ifdef HAVE_LIBSAMPLERATE
struct { /* data specific to libsamplerate */ struct src_data { /* data specific to libsamplerate */
SRC_STATE *state; SRC_STATE *state;
} src; };
#endif #endif
#ifdef HAVE_SPEEX #ifdef HAVE_SPEEX
struct { /* data specific to speex */ struct speex_data { /* data specific to speex */
SpeexResamplerState* state; SpeexResamplerState* state;
} speex; };
#endif #endif
struct { /* data specific to ffmpeg */ struct ffmpeg_data { /* data specific to ffmpeg */
struct AVResampleContext *state; struct AVResampleContext *state;
pa_memchunk buf[PA_CHANNELS_MAX]; pa_memchunk buf[PA_CHANNELS_MAX];
} ffmpeg;
}; };
static int copy_init(pa_resampler *r); static int copy_init(pa_resampler *r);
@ -355,6 +355,7 @@ void pa_resampler_free(pa_resampler *r) {
if (r->from_work_format_buf.memblock) if (r->from_work_format_buf.memblock)
pa_memblock_unref(r->from_work_format_buf.memblock); pa_memblock_unref(r->from_work_format_buf.memblock);
pa_xfree(r->impl_data);
pa_xfree(r); pa_xfree(r);
} }
@ -1256,12 +1257,14 @@ static void save_leftover(pa_resampler *r, void *buf, size_t len) {
#ifdef HAVE_LIBSAMPLERATE #ifdef HAVE_LIBSAMPLERATE
static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) { static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
SRC_DATA data; SRC_DATA data;
struct src_data *libsamplerate_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
libsamplerate_data = r->impl_data;
memset(&data, 0, sizeof(data)); memset(&data, 0, sizeof(data));
data.data_in = pa_memblock_acquire_chunk(input); data.data_in = pa_memblock_acquire_chunk(input);
@ -1273,7 +1276,7 @@ static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, un
data.src_ratio = (double) r->o_ss.rate / r->i_ss.rate; data.src_ratio = (double) r->o_ss.rate / r->i_ss.rate;
data.end_of_input = 0; data.end_of_input = 0;
pa_assert_se(src_process(r->src.state, &data) == 0); pa_assert_se(src_process(libsamplerate_data->state, &data) == 0);
if (data.input_frames_used < in_n_frames) { if (data.input_frames_used < in_n_frames) {
void *leftover_data = data.data_in + data.input_frames_used * r->o_ss.channels; void *leftover_data = data.data_in + data.input_frames_used * r->o_ss.channels;
@ -1289,36 +1292,46 @@ static void libsamplerate_resample(pa_resampler *r, const pa_memchunk *input, un
} }
static void libsamplerate_update_rates(pa_resampler *r) { static void libsamplerate_update_rates(pa_resampler *r) {
struct src_data *libsamplerate_data;
pa_assert(r); pa_assert(r);
pa_assert_se(src_set_ratio(r->src.state, (double) r->o_ss.rate / r->i_ss.rate) == 0); libsamplerate_data = r->impl_data;
pa_assert_se(src_set_ratio(libsamplerate_data->state, (double) r->o_ss.rate / r->i_ss.rate) == 0);
} }
static void libsamplerate_reset(pa_resampler *r) { static void libsamplerate_reset(pa_resampler *r) {
struct src_data *libsamplerate_data;
pa_assert(r); pa_assert(r);
pa_assert_se(src_reset(r->src.state) == 0); libsamplerate_data = r->impl_data;
pa_assert_se(src_reset(libsamplerate_data->state) == 0);
} }
static void libsamplerate_free(pa_resampler *r) { static void libsamplerate_free(pa_resampler *r) {
struct src_data *libsamplerate_data;
pa_assert(r); pa_assert(r);
if (r->src.state) libsamplerate_data = r->impl_data;
src_delete(r->src.state); if (libsamplerate_data->state)
src_delete(libsamplerate_data->state);
} }
static int libsamplerate_init(pa_resampler *r) { static int libsamplerate_init(pa_resampler *r) {
int err; int err;
struct src_data *libsamplerate_data;
pa_assert(r); pa_assert(r);
if (!(r->src.state = src_new(r->method, r->o_ss.channels, &err))) libsamplerate_data = pa_xnew(struct src_data, 1);
if (!(libsamplerate_data->state = src_new(r->method, r->o_ss.channels, &err)))
return -1; return -1;
r->impl_free = libsamplerate_free; r->impl_free = libsamplerate_free;
r->impl_update_rates = libsamplerate_update_rates; r->impl_update_rates = libsamplerate_update_rates;
r->impl_resample = libsamplerate_resample; r->impl_resample = libsamplerate_resample;
r->impl_reset = libsamplerate_reset; r->impl_reset = libsamplerate_reset;
r->impl_data = libsamplerate_data;
return 0; return 0;
} }
@ -1330,16 +1343,19 @@ static int libsamplerate_init(pa_resampler *r) {
static void speex_resample_float(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) { static void speex_resample_float(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
float *in, *out; float *in, *out;
uint32_t inf = in_n_frames, outf = *out_n_frames; uint32_t inf = in_n_frames, outf = *out_n_frames;
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
speex_data = r->impl_data;
in = pa_memblock_acquire_chunk(input); in = pa_memblock_acquire_chunk(input);
out = pa_memblock_acquire_chunk(output); out = pa_memblock_acquire_chunk(output);
pa_assert_se(speex_resampler_process_interleaved_float(r->speex.state, in, &inf, out, &outf) == 0); pa_assert_se(speex_resampler_process_interleaved_float(speex_data->state, in, &inf, out, &outf) == 0);
pa_memblock_release(input->memblock); pa_memblock_release(input->memblock);
pa_memblock_release(output->memblock); pa_memblock_release(output->memblock);
@ -1351,16 +1367,19 @@ static void speex_resample_float(pa_resampler *r, const pa_memchunk *input, unsi
static void speex_resample_int(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) { static void speex_resample_int(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
int16_t *in, *out; int16_t *in, *out;
uint32_t inf = in_n_frames, outf = *out_n_frames; uint32_t inf = in_n_frames, outf = *out_n_frames;
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
speex_data = r->impl_data;
in = pa_memblock_acquire_chunk(input); in = pa_memblock_acquire_chunk(input);
out = pa_memblock_acquire_chunk(output); out = pa_memblock_acquire_chunk(output);
pa_assert_se(speex_resampler_process_interleaved_int(r->speex.state, in, &inf, out, &outf) == 0); pa_assert_se(speex_resampler_process_interleaved_int(speex_data->state, in, &inf, out, &outf) == 0);
pa_memblock_release(input->memblock); pa_memblock_release(input->memblock);
pa_memblock_release(output->memblock); pa_memblock_release(output->memblock);
@ -1370,34 +1389,46 @@ static void speex_resample_int(pa_resampler *r, const pa_memchunk *input, unsign
} }
static void speex_update_rates(pa_resampler *r) { static void speex_update_rates(pa_resampler *r) {
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
pa_assert_se(speex_resampler_set_rate(r->speex.state, r->i_ss.rate, r->o_ss.rate) == 0); speex_data = r->impl_data;
pa_assert_se(speex_resampler_set_rate(speex_data->state, r->i_ss.rate, r->o_ss.rate) == 0);
} }
static void speex_reset(pa_resampler *r) { static void speex_reset(pa_resampler *r) {
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
pa_assert_se(speex_resampler_reset_mem(r->speex.state) == 0); speex_data = r->impl_data;
pa_assert_se(speex_resampler_reset_mem(speex_data->state) == 0);
} }
static void speex_free(pa_resampler *r) { static void speex_free(pa_resampler *r) {
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
if (!r->speex.state) speex_data = r->impl_data;
if (!speex_data->state)
return; return;
speex_resampler_destroy(r->speex.state); speex_resampler_destroy(speex_data->state);
} }
static int speex_init(pa_resampler *r) { static int speex_init(pa_resampler *r) {
int q, err; int q, err;
struct speex_data *speex_data;
pa_assert(r); pa_assert(r);
speex_data = pa_xnew(struct speex_data, 1);
r->impl_free = speex_free; r->impl_free = speex_free;
r->impl_update_rates = speex_update_rates; r->impl_update_rates = speex_update_rates;
r->impl_reset = speex_reset; r->impl_reset = speex_reset;
r->impl_data = speex_data;
if (r->method >= PA_RESAMPLER_SPEEX_FIXED_BASE && r->method <= PA_RESAMPLER_SPEEX_FIXED_MAX) { if (r->method >= PA_RESAMPLER_SPEEX_FIXED_BASE && r->method <= PA_RESAMPLER_SPEEX_FIXED_MAX) {
@ -1413,7 +1444,7 @@ static int speex_init(pa_resampler *r) {
pa_log_info("Choosing speex quality setting %i.", q); pa_log_info("Choosing speex quality setting %i.", q);
if (!(r->speex.state = speex_resampler_init(r->o_ss.channels, r->i_ss.rate, r->o_ss.rate, q, &err))) if (!(speex_data->state = speex_resampler_init(r->o_ss.channels, r->i_ss.rate, r->o_ss.rate, q, &err)))
return -1; return -1;
return 0; return 0;
@ -1426,20 +1457,22 @@ static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned
size_t fz; size_t fz;
unsigned i_index, o_index; unsigned i_index, o_index;
void *src, *dst; void *src, *dst;
struct trivial_data *trivial_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
trivial_data = r->impl_data;
fz = r->w_sz * r->o_ss.channels; fz = r->w_sz * r->o_ss.channels;
src = pa_memblock_acquire_chunk(input); src = pa_memblock_acquire_chunk(input);
dst = pa_memblock_acquire_chunk(output); dst = pa_memblock_acquire_chunk(output);
for (o_index = 0;; o_index++, r->trivial.o_counter++) { for (o_index = 0;; o_index++, trivial_data->o_counter++) {
i_index = ((uint64_t) r->trivial.o_counter * r->i_ss.rate) / r->o_ss.rate; i_index = ((uint64_t) trivial_data->o_counter * r->i_ss.rate) / r->o_ss.rate;
i_index = i_index > r->trivial.i_counter ? i_index - r->trivial.i_counter : 0; i_index = i_index > trivial_data->i_counter ? i_index - trivial_data->i_counter : 0;
if (i_index >= in_n_frames) if (i_index >= in_n_frames)
break; break;
@ -1454,32 +1487,37 @@ static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned
*out_n_frames = o_index; *out_n_frames = o_index;
r->trivial.i_counter += in_n_frames; trivial_data->i_counter += in_n_frames;
/* Normalize counters */ /* Normalize counters */
while (r->trivial.i_counter >= r->i_ss.rate) { while (trivial_data->i_counter >= r->i_ss.rate) {
pa_assert(r->trivial.o_counter >= r->o_ss.rate); pa_assert(trivial_data->o_counter >= r->o_ss.rate);
r->trivial.i_counter -= r->i_ss.rate; trivial_data->i_counter -= r->i_ss.rate;
r->trivial.o_counter -= r->o_ss.rate; trivial_data->o_counter -= r->o_ss.rate;
} }
} }
static void trivial_update_rates_or_reset(pa_resampler *r) { static void trivial_update_rates_or_reset(pa_resampler *r) {
struct trivial_data *trivial_data;
pa_assert(r); pa_assert(r);
r->trivial.i_counter = 0; trivial_data = r->impl_data;
r->trivial.o_counter = 0;
trivial_data->i_counter = 0;
trivial_data->o_counter = 0;
} }
static int trivial_init(pa_resampler*r) { static int trivial_init(pa_resampler*r) {
struct trivial_data *trivial_data;
pa_assert(r); pa_assert(r);
r->trivial.o_counter = r->trivial.i_counter = 0; trivial_data = pa_xnew0(struct trivial_data, 1);
r->impl_resample = trivial_resample; r->impl_resample = trivial_resample;
r->impl_update_rates = trivial_update_rates_or_reset; r->impl_update_rates = trivial_update_rates_or_reset;
r->impl_reset = trivial_update_rates_or_reset; r->impl_reset = trivial_update_rates_or_reset;
r->impl_data = trivial_data;
return 0; return 0;
} }
@ -1490,21 +1528,23 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
unsigned c, o_index = 0; unsigned c, o_index = 0;
unsigned i, i_end = 0; unsigned i, i_end = 0;
void *src, *dst; void *src, *dst;
struct peaks_data *peaks_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
peaks_data = r->impl_data;
src = pa_memblock_acquire_chunk(input); src = pa_memblock_acquire_chunk(input);
dst = pa_memblock_acquire_chunk(output); dst = pa_memblock_acquire_chunk(output);
i = ((uint64_t) r->peaks.o_counter * r->i_ss.rate) / r->o_ss.rate; i = ((uint64_t) peaks_data->o_counter * r->i_ss.rate) / r->o_ss.rate;
i = i > r->peaks.i_counter ? i - r->peaks.i_counter : 0; i = i > peaks_data->i_counter ? i - peaks_data->i_counter : 0;
while (i_end < in_n_frames) { while (i_end < in_n_frames) {
i_end = ((uint64_t) (r->peaks.o_counter + 1) * r->i_ss.rate) / r->o_ss.rate; i_end = ((uint64_t) (peaks_data->o_counter + 1) * r->i_ss.rate) / r->o_ss.rate;
i_end = i_end > r->peaks.i_counter ? i_end - r->peaks.i_counter : 0; i_end = i_end > peaks_data->i_counter ? i_end - peaks_data->i_counter : 0;
pa_assert_fp(o_index * r->w_sz * r->o_ss.channels < pa_memblock_get_length(output->memblock)); pa_assert_fp(o_index * r->w_sz * r->o_ss.channels < pa_memblock_get_length(output->memblock));
@ -1516,14 +1556,14 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
for (; i < i_end && i < in_n_frames; i++) { for (; i < i_end && i < in_n_frames; i++) {
float n = fabsf(*s++); float n = fabsf(*s++);
if (n > r->peaks.max_f[0]) if (n > peaks_data->max_f[0])
r->peaks.max_f[0] = n; peaks_data->max_f[0] = n;
} }
if (i == i_end) { if (i == i_end) {
*d = r->peaks.max_f[0]; *d = peaks_data->max_f[0];
r->peaks.max_f[0] = 0; peaks_data->max_f[0] = 0;
o_index++, r->peaks.o_counter++; o_index++, peaks_data->o_counter++;
} }
} else if (r->work_format == PA_SAMPLE_S16NE) { } else if (r->work_format == PA_SAMPLE_S16NE) {
int16_t *s = (int16_t*) src + r->o_ss.channels * i; int16_t *s = (int16_t*) src + r->o_ss.channels * i;
@ -1533,16 +1573,16 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
for (c = 0; c < r->o_ss.channels; c++) { for (c = 0; c < r->o_ss.channels; c++) {
int16_t n = abs(*s++); int16_t n = abs(*s++);
if (n > r->peaks.max_i[c]) if (n > peaks_data->max_i[c])
r->peaks.max_i[c] = n; peaks_data->max_i[c] = n;
} }
if (i == i_end) { if (i == i_end) {
for (c = 0; c < r->o_ss.channels; c++, d++) { for (c = 0; c < r->o_ss.channels; c++, d++) {
*d = r->peaks.max_i[c]; *d = peaks_data->max_i[c];
r->peaks.max_i[c] = 0; peaks_data->max_i[c] = 0;
} }
o_index++, r->peaks.o_counter++; o_index++, peaks_data->o_counter++;
} }
} else { } else {
float *s = (float*) src + r->o_ss.channels * i; float *s = (float*) src + r->o_ss.channels * i;
@ -1552,16 +1592,16 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
for (c = 0; c < r->o_ss.channels; c++) { for (c = 0; c < r->o_ss.channels; c++) {
float n = fabsf(*s++); float n = fabsf(*s++);
if (n > r->peaks.max_f[c]) if (n > peaks_data->max_f[c])
r->peaks.max_f[c] = n; peaks_data->max_f[c] = n;
} }
if (i == i_end) { if (i == i_end) {
for (c = 0; c < r->o_ss.channels; c++, d++) { for (c = 0; c < r->o_ss.channels; c++, d++) {
*d = r->peaks.max_f[c]; *d = peaks_data->max_f[c];
r->peaks.max_f[c] = 0; peaks_data->max_f[c] = 0;
} }
o_index++, r->peaks.o_counter++; o_index++, peaks_data->o_counter++;
} }
} }
} }
@ -1571,36 +1611,39 @@ static void peaks_resample(pa_resampler *r, const pa_memchunk *input, unsigned i
*out_n_frames = o_index; *out_n_frames = o_index;
r->peaks.i_counter += in_n_frames; peaks_data->i_counter += in_n_frames;
/* Normalize counters */ /* Normalize counters */
while (r->peaks.i_counter >= r->i_ss.rate) { while (peaks_data->i_counter >= r->i_ss.rate) {
pa_assert(r->peaks.o_counter >= r->o_ss.rate); pa_assert(peaks_data->o_counter >= r->o_ss.rate);
r->peaks.i_counter -= r->i_ss.rate; peaks_data->i_counter -= r->i_ss.rate;
r->peaks.o_counter -= r->o_ss.rate; peaks_data->o_counter -= r->o_ss.rate;
} }
} }
static void peaks_update_rates_or_reset(pa_resampler *r) { static void peaks_update_rates_or_reset(pa_resampler *r) {
struct peaks_data *peaks_data;
pa_assert(r); pa_assert(r);
r->peaks.i_counter = 0; peaks_data = r->impl_data;
r->peaks.o_counter = 0;
peaks_data->i_counter = 0;
peaks_data->o_counter = 0;
} }
static int peaks_init(pa_resampler*r) { static int peaks_init(pa_resampler*r) {
struct peaks_data *peaks_data;
pa_assert(r); pa_assert(r);
pa_assert(r->i_ss.rate >= r->o_ss.rate); pa_assert(r->i_ss.rate >= r->o_ss.rate);
pa_assert(r->work_format == PA_SAMPLE_S16NE || r->work_format == PA_SAMPLE_FLOAT32NE); pa_assert(r->work_format == PA_SAMPLE_S16NE || r->work_format == PA_SAMPLE_FLOAT32NE);
r->peaks.o_counter = r->peaks.i_counter = 0; peaks_data = pa_xnew0(struct peaks_data, 1);
memset(r->peaks.max_i, 0, sizeof(r->peaks.max_i));
memset(r->peaks.max_f, 0, sizeof(r->peaks.max_f));
r->impl_resample = peaks_resample; r->impl_resample = peaks_resample;
r->impl_update_rates = peaks_update_rates_or_reset; r->impl_update_rates = peaks_update_rates_or_reset;
r->impl_reset = peaks_update_rates_or_reset; r->impl_reset = peaks_update_rates_or_reset;
r->impl_data = peaks_data;
return 0; return 0;
} }
@ -1610,12 +1653,15 @@ static int peaks_init(pa_resampler*r) {
static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) { static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned in_n_frames, pa_memchunk *output, unsigned *out_n_frames) {
unsigned used_frames = 0, c; unsigned used_frames = 0, c;
int previous_consumed_frames = -1; int previous_consumed_frames = -1;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r); pa_assert(r);
pa_assert(input); pa_assert(input);
pa_assert(output); pa_assert(output);
pa_assert(out_n_frames); pa_assert(out_n_frames);
ffmpeg_data = r->impl_data;
for (c = 0; c < r->o_ss.channels; c++) { for (c = 0; c < r->o_ss.channels; c++) {
unsigned u; unsigned u;
pa_memblock *b, *w; pa_memblock *b, *w;
@ -1623,7 +1669,7 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
int consumed_frames; int consumed_frames;
/* Allocate a new block */ /* Allocate a new block */
b = pa_memblock_new(r->mempool, r->ffmpeg.buf[c].length + in_n_frames * sizeof(int16_t)); b = pa_memblock_new(r->mempool, ffmpeg_data->buf[c].length + in_n_frames * sizeof(int16_t));
p = pa_memblock_acquire(b); p = pa_memblock_acquire(b);
/* Now copy the input data, splitting up channels */ /* Now copy the input data, splitting up channels */
@ -1641,7 +1687,7 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
q = pa_memblock_acquire(w); q = pa_memblock_acquire(w);
/* Now, resample */ /* Now, resample */
used_frames = (unsigned) av_resample(r->ffmpeg.state, used_frames = (unsigned) av_resample(ffmpeg_data->state,
q, p, q, p,
&consumed_frames, &consumed_frames,
(int) in_n_frames, (int) *out_n_frames, (int) in_n_frames, (int) *out_n_frames,
@ -1679,35 +1725,41 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
static void ffmpeg_free(pa_resampler *r) { static void ffmpeg_free(pa_resampler *r) {
unsigned c; unsigned c;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r); pa_assert(r);
if (r->ffmpeg.state) ffmpeg_data = r->impl_data;
av_resample_close(r->ffmpeg.state); if (ffmpeg_data->state)
av_resample_close(ffmpeg_data->state);
for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++) for (c = 0; c < PA_ELEMENTSOF(ffmpeg_data->buf); c++)
if (r->ffmpeg.buf[c].memblock) if (ffmpeg_data->buf[c].memblock)
pa_memblock_unref(r->ffmpeg.buf[c].memblock); pa_memblock_unref(ffmpeg_data->buf[c].memblock);
} }
static int ffmpeg_init(pa_resampler *r) { static int ffmpeg_init(pa_resampler *r) {
unsigned c; unsigned c;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r); pa_assert(r);
ffmpeg_data = pa_xnew(struct ffmpeg_data, 1);
/* We could probably implement different quality levels by /* We could probably implement different quality levels by
* adjusting the filter parameters here. However, ffmpeg * adjusting the filter parameters here. However, ffmpeg
* internally only uses these hardcoded values, so let's use them * internally only uses these hardcoded values, so let's use them
* here for now as well until ffmpeg makes this configurable. */ * here for now as well until ffmpeg makes this configurable. */
if (!(r->ffmpeg.state = av_resample_init((int) r->o_ss.rate, (int) r->i_ss.rate, 16, 10, 0, 0.8))) if (!(ffmpeg_data->state = av_resample_init((int) r->o_ss.rate, (int) r->i_ss.rate, 16, 10, 0, 0.8)))
return -1; return -1;
r->impl_free = ffmpeg_free; r->impl_free = ffmpeg_free;
r->impl_resample = ffmpeg_resample; r->impl_resample = ffmpeg_resample;
r->impl_data = (void *) ffmpeg_data;
for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++) for (c = 0; c < PA_ELEMENTSOF(ffmpeg_data->buf); c++)
pa_memchunk_reset(&r->ffmpeg.buf[c]); pa_memchunk_reset(&ffmpeg_data->buf[c]);
return 0; return 0;
} }