mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-05 13:29:57 -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_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_data;
};
struct { /* data specific to the trivial resampler */
unsigned o_counter;
unsigned i_counter;
} trivial;
struct trivial_data { /* data specific to the trivial resampler */
unsigned o_counter;
unsigned i_counter;
};
struct { /* data specific to the peak finder pseudo resampler */
unsigned o_counter;
unsigned i_counter;
struct peaks_data { /* data specific to the peak finder pseudo resampler */
unsigned o_counter;
unsigned i_counter;
float max_f[PA_CHANNELS_MAX];
int16_t max_i[PA_CHANNELS_MAX];
} peaks;
float max_f[PA_CHANNELS_MAX];
int16_t max_i[PA_CHANNELS_MAX];
};
#ifdef HAVE_LIBSAMPLERATE
struct { /* data specific to libsamplerate */
SRC_STATE *state;
} src;
struct src_data { /* data specific to libsamplerate */
SRC_STATE *state;
};
#endif
#ifdef HAVE_SPEEX
struct { /* data specific to speex */
SpeexResamplerState* state;
} speex;
struct speex_data { /* data specific to speex */
SpeexResamplerState* state;
};
#endif
struct { /* data specific to ffmpeg */
struct AVResampleContext *state;
pa_memchunk buf[PA_CHANNELS_MAX];
} ffmpeg;
struct ffmpeg_data { /* data specific to ffmpeg */
struct AVResampleContext *state;
pa_memchunk buf[PA_CHANNELS_MAX];
};
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)
pa_memblock_unref(r->from_work_format_buf.memblock);
pa_xfree(r->impl_data);
pa_xfree(r);
}
@ -1256,12 +1257,14 @@ static void save_leftover(pa_resampler *r, void *buf, size_t len) {
#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) {
SRC_DATA data;
struct src_data *libsamplerate_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
libsamplerate_data = r->impl_data;
memset(&data, 0, sizeof(data));
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.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) {
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) {
struct src_data *libsamplerate_data;
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) {
struct src_data *libsamplerate_data;
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) {
struct src_data *libsamplerate_data;
pa_assert(r);
if (r->src.state)
src_delete(r->src.state);
libsamplerate_data = r->impl_data;
if (libsamplerate_data->state)
src_delete(libsamplerate_data->state);
}
static int libsamplerate_init(pa_resampler *r) {
int err;
struct src_data *libsamplerate_data;
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;
r->impl_free = libsamplerate_free;
r->impl_update_rates = libsamplerate_update_rates;
r->impl_resample = libsamplerate_resample;
r->impl_reset = libsamplerate_reset;
r->impl_data = libsamplerate_data;
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) {
float *in, *out;
uint32_t inf = in_n_frames, outf = *out_n_frames;
struct speex_data *speex_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
speex_data = r->impl_data;
in = pa_memblock_acquire_chunk(input);
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(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) {
int16_t *in, *out;
uint32_t inf = in_n_frames, outf = *out_n_frames;
struct speex_data *speex_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
speex_data = r->impl_data;
in = pa_memblock_acquire_chunk(input);
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(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) {
struct speex_data *speex_data;
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) {
struct speex_data *speex_data;
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) {
struct speex_data *speex_data;
pa_assert(r);
if (!r->speex.state)
speex_data = r->impl_data;
if (!speex_data->state)
return;
speex_resampler_destroy(r->speex.state);
speex_resampler_destroy(speex_data->state);
}
static int speex_init(pa_resampler *r) {
int q, err;
struct speex_data *speex_data;
pa_assert(r);
speex_data = pa_xnew(struct speex_data, 1);
r->impl_free = speex_free;
r->impl_update_rates = speex_update_rates;
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) {
@ -1413,7 +1444,7 @@ static int speex_init(pa_resampler *r) {
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 0;
@ -1426,20 +1457,22 @@ static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned
size_t fz;
unsigned i_index, o_index;
void *src, *dst;
struct trivial_data *trivial_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
trivial_data = r->impl_data;
fz = r->w_sz * r->o_ss.channels;
src = pa_memblock_acquire_chunk(input);
dst = pa_memblock_acquire_chunk(output);
for (o_index = 0;; o_index++, r->trivial.o_counter++) {
i_index = ((uint64_t) r->trivial.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;
for (o_index = 0;; o_index++, trivial_data->o_counter++) {
i_index = ((uint64_t) trivial_data->o_counter * r->i_ss.rate) / r->o_ss.rate;
i_index = i_index > trivial_data->i_counter ? i_index - trivial_data->i_counter : 0;
if (i_index >= in_n_frames)
break;
@ -1454,32 +1487,37 @@ static void trivial_resample(pa_resampler *r, const pa_memchunk *input, unsigned
*out_n_frames = o_index;
r->trivial.i_counter += in_n_frames;
trivial_data->i_counter += in_n_frames;
/* Normalize counters */
while (r->trivial.i_counter >= r->i_ss.rate) {
pa_assert(r->trivial.o_counter >= r->o_ss.rate);
while (trivial_data->i_counter >= r->i_ss.rate) {
pa_assert(trivial_data->o_counter >= r->o_ss.rate);
r->trivial.i_counter -= r->i_ss.rate;
r->trivial.o_counter -= r->o_ss.rate;
trivial_data->i_counter -= r->i_ss.rate;
trivial_data->o_counter -= r->o_ss.rate;
}
}
static void trivial_update_rates_or_reset(pa_resampler *r) {
struct trivial_data *trivial_data;
pa_assert(r);
r->trivial.i_counter = 0;
r->trivial.o_counter = 0;
trivial_data = r->impl_data;
trivial_data->i_counter = 0;
trivial_data->o_counter = 0;
}
static int trivial_init(pa_resampler*r) {
struct trivial_data *trivial_data;
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_update_rates = trivial_update_rates_or_reset;
r->impl_reset = trivial_update_rates_or_reset;
r->impl_data = trivial_data;
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 i, i_end = 0;
void *src, *dst;
struct peaks_data *peaks_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
peaks_data = r->impl_data;
src = pa_memblock_acquire_chunk(input);
dst = pa_memblock_acquire_chunk(output);
i = ((uint64_t) r->peaks.o_counter * r->i_ss.rate) / r->o_ss.rate;
i = i > r->peaks.i_counter ? i - r->peaks.i_counter : 0;
i = ((uint64_t) peaks_data->o_counter * r->i_ss.rate) / r->o_ss.rate;
i = i > peaks_data->i_counter ? i - peaks_data->i_counter : 0;
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 = i_end > r->peaks.i_counter ? i_end - r->peaks.i_counter : 0;
i_end = ((uint64_t) (peaks_data->o_counter + 1) * r->i_ss.rate) / r->o_ss.rate;
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));
@ -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++) {
float n = fabsf(*s++);
if (n > r->peaks.max_f[0])
r->peaks.max_f[0] = n;
if (n > peaks_data->max_f[0])
peaks_data->max_f[0] = n;
}
if (i == i_end) {
*d = r->peaks.max_f[0];
r->peaks.max_f[0] = 0;
o_index++, r->peaks.o_counter++;
*d = peaks_data->max_f[0];
peaks_data->max_f[0] = 0;
o_index++, peaks_data->o_counter++;
}
} else if (r->work_format == PA_SAMPLE_S16NE) {
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++) {
int16_t n = abs(*s++);
if (n > r->peaks.max_i[c])
r->peaks.max_i[c] = n;
if (n > peaks_data->max_i[c])
peaks_data->max_i[c] = n;
}
if (i == i_end) {
for (c = 0; c < r->o_ss.channels; c++, d++) {
*d = r->peaks.max_i[c];
r->peaks.max_i[c] = 0;
*d = peaks_data->max_i[c];
peaks_data->max_i[c] = 0;
}
o_index++, r->peaks.o_counter++;
o_index++, peaks_data->o_counter++;
}
} else {
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++) {
float n = fabsf(*s++);
if (n > r->peaks.max_f[c])
r->peaks.max_f[c] = n;
if (n > peaks_data->max_f[c])
peaks_data->max_f[c] = n;
}
if (i == i_end) {
for (c = 0; c < r->o_ss.channels; c++, d++) {
*d = r->peaks.max_f[c];
r->peaks.max_f[c] = 0;
*d = peaks_data->max_f[c];
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;
r->peaks.i_counter += in_n_frames;
peaks_data->i_counter += in_n_frames;
/* Normalize counters */
while (r->peaks.i_counter >= r->i_ss.rate) {
pa_assert(r->peaks.o_counter >= r->o_ss.rate);
while (peaks_data->i_counter >= r->i_ss.rate) {
pa_assert(peaks_data->o_counter >= r->o_ss.rate);
r->peaks.i_counter -= r->i_ss.rate;
r->peaks.o_counter -= r->o_ss.rate;
peaks_data->i_counter -= r->i_ss.rate;
peaks_data->o_counter -= r->o_ss.rate;
}
}
static void peaks_update_rates_or_reset(pa_resampler *r) {
struct peaks_data *peaks_data;
pa_assert(r);
r->peaks.i_counter = 0;
r->peaks.o_counter = 0;
peaks_data = r->impl_data;
peaks_data->i_counter = 0;
peaks_data->o_counter = 0;
}
static int peaks_init(pa_resampler*r) {
struct peaks_data *peaks_data;
pa_assert(r);
pa_assert(r->i_ss.rate >= r->o_ss.rate);
pa_assert(r->work_format == PA_SAMPLE_S16NE || r->work_format == PA_SAMPLE_FLOAT32NE);
r->peaks.o_counter = r->peaks.i_counter = 0;
memset(r->peaks.max_i, 0, sizeof(r->peaks.max_i));
memset(r->peaks.max_f, 0, sizeof(r->peaks.max_f));
peaks_data = pa_xnew0(struct peaks_data, 1);
r->impl_resample = peaks_resample;
r->impl_update_rates = peaks_update_rates_or_reset;
r->impl_reset = peaks_update_rates_or_reset;
r->impl_data = peaks_data;
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) {
unsigned used_frames = 0, c;
int previous_consumed_frames = -1;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r);
pa_assert(input);
pa_assert(output);
pa_assert(out_n_frames);
ffmpeg_data = r->impl_data;
for (c = 0; c < r->o_ss.channels; c++) {
unsigned u;
pa_memblock *b, *w;
@ -1623,7 +1669,7 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
int consumed_frames;
/* 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);
/* 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);
/* Now, resample */
used_frames = (unsigned) av_resample(r->ffmpeg.state,
used_frames = (unsigned) av_resample(ffmpeg_data->state,
q, p,
&consumed_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) {
unsigned c;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r);
if (r->ffmpeg.state)
av_resample_close(r->ffmpeg.state);
ffmpeg_data = r->impl_data;
if (ffmpeg_data->state)
av_resample_close(ffmpeg_data->state);
for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++)
if (r->ffmpeg.buf[c].memblock)
pa_memblock_unref(r->ffmpeg.buf[c].memblock);
for (c = 0; c < PA_ELEMENTSOF(ffmpeg_data->buf); c++)
if (ffmpeg_data->buf[c].memblock)
pa_memblock_unref(ffmpeg_data->buf[c].memblock);
}
static int ffmpeg_init(pa_resampler *r) {
unsigned c;
struct ffmpeg_data *ffmpeg_data;
pa_assert(r);
ffmpeg_data = pa_xnew(struct ffmpeg_data, 1);
/* We could probably implement different quality levels by
* adjusting the filter parameters here. However, ffmpeg
* internally only uses these hardcoded values, so let's use them
* 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;
r->impl_free = ffmpeg_free;
r->impl_resample = ffmpeg_resample;
r->impl_data = (void *) ffmpeg_data;
for (c = 0; c < PA_ELEMENTSOF(r->ffmpeg.buf); c++)
pa_memchunk_reset(&r->ffmpeg.buf[c]);
for (c = 0; c < PA_ELEMENTSOF(ffmpeg_data->buf); c++)
pa_memchunk_reset(&ffmpeg_data->buf[c]);
return 0;
}