[PATCH 01/18] resampler: Make resampler struct implementation agnostic

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



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.
---
 src/pulsecore/resampler.c | 223 +++++++++++++++++++++++++++++-----------------
 1 file changed, 139 insertions(+), 84 deletions(-)

diff --git a/src/pulsecore/resampler.c b/src/pulsecore/resampler.c
index cdfaf8f..f70f186 100644
--- a/src/pulsecore/resampler.c
+++ b/src/pulsecore/resampler.c
@@ -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 { /* data specific to the peak finder pseudo resampler */
-        unsigned o_counter;
-        unsigned i_counter;
+struct trivial { /* data specific to the trivial resampler */
+    unsigned o_counter;
+    unsigned i_counter;
+};
 
-        float max_f[PA_CHANNELS_MAX];
-        int16_t max_i[PA_CHANNELS_MAX];
+struct peaks{ /* data specific to the peak finder pseudo resampler */
+    unsigned o_counter;
+    unsigned i_counter;
 
-    } 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 specific to libsamplerate */
+    SRC_STATE *state;
+};
 #endif
 
 #ifdef HAVE_SPEEX
-    struct { /* data specific to speex */
-        SpeexResamplerState* state;
-    } speex;
+struct speex{ /* 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 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 *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 *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 *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 *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 *libsamplerate_data;
 
     pa_assert(r);
 
-    if (!(r->src.state = src_new(r->method, r->o_ss.channels, &err)))
+    libsamplerate_data = pa_xnew(struct src, 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 *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 *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 *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 *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 *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 *speex_data;
 
     pa_assert(r);
 
+    speex_data = pa_xnew(struct speex, 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 *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 *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 *trivial_data;
     pa_assert(r);
 
-    r->trivial.o_counter = r->trivial.i_counter = 0;
+    trivial_data = pa_xnew0(struct trivial, 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 *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->i_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->i_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,42 @@ 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 *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 *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_xnew(struct peaks, 1);
+    peaks_data->o_counter = peaks_data->i_counter = 0;
+    memset(peaks_data->max_i, 0, sizeof(peaks_data->max_i));
+    memset(peaks_data->max_f, 0, sizeof(peaks_data->max_f));
 
     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 +1656,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 *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 +1672,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 +1690,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 +1728,41 @@ static void ffmpeg_resample(pa_resampler *r, const pa_memchunk *input, unsigned
 
 static void ffmpeg_free(pa_resampler *r) {
     unsigned c;
+    struct ffmpeg *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 *ffmpeg_data;
 
     pa_assert(r);
 
+    ffmpeg_data = pa_xnew(struct ffmpeg, 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;
 }
-- 
1.8.3.2



[Index of Archives]     [Linux Audio Users]     [AMD Graphics]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux