code.delx.au - pulseaudio/blob - polyp/resampler.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of polypaudio.
   5
   6   polypaudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published
   8   by the Free Software Foundation; either version 2 of the License,
   9   or (at your option) any later version.
  10
  11   polypaudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with polypaudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdlib.h>
  27 #include <assert.h>
  28
  29 #include <samplerate.h>
  30
  31 #include "resampler.h"
  32 #include "sconv.h"
  33 #include "xmalloc.h"
  34
  35 struct pa_resampler {
  36     struct pa_sample_spec i_ss, o_ss;
  37     float* i_buf, *o_buf;
  38     unsigned i_alloc, o_alloc;
  39     size_t i_sz, o_sz;
  40
  41     int channels;
  42
  43     pa_convert_to_float32_func_t to_float32_func;
  44     pa_convert_from_float32_func_t from_float32_func;
  45     SRC_STATE *src_state;
  46
  47     struct pa_memblock_stat *memblock_stat;
  48 };
  49
  50 struct pa_resampler* pa_resampler_new(const struct pa_sample_spec *a, const struct pa_sample_spec *b, struct pa_memblock_stat *s) {
  51     struct pa_resampler *r = NULL;
  52     int err;
  53     assert(a && b && pa_sample_spec_valid(a) && pa_sample_spec_valid(b));
  54
  55     if (a->channels != b->channels && a->channels != 1 && b->channels != 1)
  56         goto fail;
  57
  58     if (a->format == PA_SAMPLE_ALAW || a->format == PA_SAMPLE_ULAW || b->format == PA_SAMPLE_ALAW || b->format == PA_SAMPLE_ULAW)
  59         goto fail;
  60
  61     r = pa_xmalloc(sizeof(struct pa_resampler));
  62
  63     r->channels = a->channels;
  64     if (b->channels < r->channels)
  65         r->channels = b->channels;
  66
  67     r->i_buf = r->o_buf = NULL;
  68     r->i_alloc = r->o_alloc = 0;
  69
  70     if (a->rate != b->rate) {
  71         r->src_state = src_new(SRC_SINC_FASTEST, r->channels, &err);
  72         if (err != 0 || !r->src_state)
  73             goto fail;
  74     } else
  75         r->src_state = NULL;
  76
  77     r->i_ss = *a;
  78     r->o_ss = *b;
  79
  80     r->i_sz = pa_frame_size(a);
  81     r->o_sz = pa_frame_size(b);
  82
  83     r->to_float32_func = pa_get_convert_to_float32_function(a->format);
  84     r->from_float32_func = pa_get_convert_from_float32_function(b->format);
  85
  86     assert(r->to_float32_func && r->from_float32_func);
  87
  88     r->memblock_stat = s;
  89
  90     return r;
  91
  92 fail:
  93     if (r)
  94         pa_xfree(r);
  95
  96     return NULL;
  97 }
  98
  99 void pa_resampler_free(struct pa_resampler *r) {
 100     assert(r);
 101     if (r->src_state)
 102         src_delete(r->src_state);
 103     pa_xfree(r->i_buf);
 104     pa_xfree(r->o_buf);
 105     pa_xfree(r);
 106 }
 107
 108 size_t pa_resampler_request(struct pa_resampler *r, size_t out_length) {
 109     assert(r && (out_length % r->o_sz) == 0);
 110
 111     return (((out_length / r->o_sz)*r->i_ss.rate)/r->o_ss.rate) * r->i_sz;
 112 }
 113
 114
 115 void pa_resampler_run(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out) {
 116     unsigned i_nchannels, o_nchannels, ins, ons, eff_ins, eff_ons;
 117     float *cbuf;
 118     assert(r && in && out && in->length && in->memblock && (in->length % r->i_sz) == 0);
 119
 120     /* How many input samples? */
 121     ins = in->length/r->i_sz;
 122
 123     /* How much space for output samples? */
 124     if (r->src_state)
 125         ons = (ins*r->o_ss.rate/r->i_ss.rate)+1024;
 126     else
 127         ons = ins;
 128
 129     /* How many channels? */
 130     if (r->i_ss.channels == r->o_ss.channels) {
 131         i_nchannels = o_nchannels = 1;
 132         eff_ins = ins*r->i_ss.channels; /* effective samples */
 133         eff_ons = ons*r->o_ss.channels;
 134     } else {
 135         i_nchannels = r->i_ss.channels;
 136         o_nchannels = r->o_ss.channels;
 137         eff_ins = ins;
 138         eff_ons = ons;
 139     }
 140
 141     out->memblock = pa_memblock_new(out->length = (ons*r->o_sz), r->memblock_stat);
 142     out->index = 0;
 143     assert(out->memblock);
 144
 145     if (r->i_alloc < eff_ins)
 146         r->i_buf = pa_xrealloc(r->i_buf, sizeof(float) * (r->i_alloc = eff_ins));
 147     assert(r->i_buf);
 148
 149     r->to_float32_func(eff_ins, in->memblock->data+in->index, i_nchannels, r->i_buf);
 150
 151     if (r->src_state) {
 152         int ret;
 153         SRC_DATA data;
 154
 155         if (r->o_alloc < eff_ons)
 156             r->o_buf = pa_xrealloc(r->o_buf, sizeof(float) * (r->o_alloc = eff_ons));
 157         assert(r->o_buf);
 158
 159         data.data_in = r->i_buf;
 160         data.input_frames = ins;
 161
 162         data.data_out = r->o_buf;
 163         data.output_frames = ons;
 164
 165         data.src_ratio = (double) r->o_ss.rate / r->i_ss.rate;
 166         data.end_of_input = 0;
 167
 168         ret = src_process(r->src_state, &data);
 169         assert(ret == 0);
 170         assert((unsigned) data.input_frames_used == ins);
 171
 172         cbuf = r->o_buf;
 173         ons = data.output_frames_gen;
 174
 175         if (r->i_ss.channels == r->o_ss.channels)
 176             eff_ons = ons*r->o_ss.channels;
 177         else
 178             eff_ons = ons;
 179     } else
 180         cbuf = r->i_buf;
 181
 182     r->from_float32_func(eff_ons, cbuf, out->memblock->data+out->index, o_nchannels);
 183     out->length = ons*r->o_sz;
 184 }