code.delx.au - pulseaudio/blob - src/pulsecore/remap.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2004-2006 Lennart Poettering
   5   Copyright 2009 Wim Taymans <wim.taymans@collabora.co.uk.com>
   6
   7   PulseAudio is free software; you can redistribute it and/or modify
   8   it under the terms of the GNU Lesser General Public License as published
   9   by the Free Software Foundation; either version 2.1 of the License,
  10   or (at your option) any later version.
  11
  12   PulseAudio is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with PulseAudio; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  20   USA.
  21 ***/
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <string.h>
  28
  29 #include <pulse/sample.h>
  30 #include <pulse/volume.h>
  31 #include <pulsecore/log.h>
  32 #include <pulsecore/macro.h>
  33
  34 #include "remap.h"
  35
  36 static void remap_mono_to_stereo_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
  37     unsigned i;
  38
  39     for (i = n >> 2; i; i--) {
  40         dst[0] = dst[1] = src[0];
  41         dst[2] = dst[3] = src[1];
  42         dst[4] = dst[5] = src[2];
  43         dst[6] = dst[7] = src[3];
  44         src += 4;
  45         dst += 8;
  46     }
  47     for (i = n & 3; i; i--) {
  48         dst[0] = dst[1] = src[0];
  49         src++;
  50         dst += 2;
  51     }
  52 }
  53
  54 static void remap_mono_to_stereo_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
  55     unsigned i;
  56
  57     for (i = n >> 2; i; i--) {
  58         dst[0] = dst[1] = src[0];
  59         dst[2] = dst[3] = src[1];
  60         dst[4] = dst[5] = src[2];
  61         dst[6] = dst[7] = src[3];
  62         src += 4;
  63         dst += 8;
  64     }
  65     for (i = n & 3; i; i--) {
  66         dst[0] = dst[1] = src[0];
  67         src++;
  68         dst += 2;
  69     }
  70 }
  71
  72 static void remap_channels_matrix_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
  73     unsigned oc, ic, i;
  74     unsigned n_ic, n_oc;
  75
  76     n_ic = m->i_ss.channels;
  77     n_oc = m->o_ss.channels;
  78
  79     memset(dst, 0, n * sizeof(int16_t) * n_oc);
  80
  81     for (oc = 0; oc < n_oc; oc++) {
  82
  83         for (ic = 0; ic < n_ic; ic++) {
  84             int16_t *d = dst + oc;
  85             const int16_t *s = src + ic;
  86             int32_t vol = m->map_table_i[oc][ic];
  87
  88             if (vol <= 0)
  89                 continue;
  90
  91             if (vol >= 0x10000) {
  92                 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
  93                     *d += *s;
  94             } else {
  95                 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
  96                     *d += (int16_t) (((int32_t)*s * vol) >> 16);
  97             }
  98         }
  99     }
 100 }
 101
 102 static void remap_channels_matrix_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
 103     unsigned oc, ic, i;
 104     unsigned n_ic, n_oc;
 105
 106     n_ic = m->i_ss.channels;
 107     n_oc = m->o_ss.channels;
 108
 109     memset(dst, 0, n * sizeof(float) * n_oc);
 110
 111     for (oc = 0; oc < n_oc; oc++) {
 112
 113         for (ic = 0; ic < n_ic; ic++) {
 114             float *d = dst + oc;
 115             const float *s = src + ic;
 116             float vol = m->map_table_f[oc][ic];
 117
 118             if (vol <= 0.0f)
 119                 continue;
 120
 121             if (vol >= 1.0f) {
 122                 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
 123                     *d += *s;
 124             } else {
 125                 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
 126                     *d += *s * vol;
 127             }
 128         }
 129     }
 130 }
 131
 132 bool pa_setup_remap_arrange(const pa_remap_t *m, int8_t arrange[PA_CHANNELS_MAX]) {
 133     unsigned ic, oc;
 134     unsigned n_ic, n_oc;
 135
 136     pa_assert(m);
 137
 138     n_ic = m->i_ss.channels;
 139     n_oc = m->o_ss.channels;
 140
 141     for (oc = 0; oc < n_oc; oc++) {
 142         arrange[oc] = -1;
 143         for (ic = 0; ic < n_ic; ic++) {
 144             int32_t vol = m->map_table_i[oc][ic];
 145
 146             /* input channel is not used */
 147             if (vol == 0)
 148                 continue;
 149
 150             /* if mixing this channel, we cannot just rearrange */
 151             if (vol != 0x10000 || arrange[oc] >= 0)
 152                 return false;
 153
 154             arrange[oc] = ic;
 155         }
 156     }
 157
 158     return true;
 159 }
 160
 161 void pa_set_remap_func(pa_remap_t *m, pa_do_remap_func_t func_s16,
 162     pa_do_remap_func_t func_float) {
 163
 164     pa_assert(m);
 165
 166     if (m->format == PA_SAMPLE_S16NE)
 167         m->do_remap = func_s16;
 168     else if (m->format == PA_SAMPLE_FLOAT32NE)
 169         m->do_remap = func_float;
 170     else
 171         pa_assert_not_reached();
 172 }
 173
 174 /* set the function that will execute the remapping based on the matrices */
 175 static void init_remap_c(pa_remap_t *m) {
 176     unsigned n_oc, n_ic;
 177
 178     n_oc = m->o_ss.channels;
 179     n_ic = m->i_ss.channels;
 180
 181     /* find some common channel remappings, fall back to full matrix operation. */
 182     if (n_ic == 1 && n_oc == 2 &&
 183             m->map_table_i[0][0] == 0x10000 && m->map_table_i[1][0] == 0x10000) {
 184
 185         pa_log_info("Using mono to stereo remapping");
 186         pa_set_remap_func(m, (pa_do_remap_func_t) remap_mono_to_stereo_s16ne_c,
 187             (pa_do_remap_func_t) remap_mono_to_stereo_float32ne_c);
 188     } else {
 189         pa_log_info("Using generic matrix remapping");
 190
 191         pa_set_remap_func(m, (pa_do_remap_func_t) remap_channels_matrix_s16ne_c,
 192             (pa_do_remap_func_t) remap_channels_matrix_float32ne_c);
 193     }
 194 }
 195
 196 /* default C implementation */
 197 static pa_init_remap_func_t init_remap_func = init_remap_c;
 198
 199 void pa_init_remap_func(pa_remap_t *m) {
 200     pa_assert(init_remap_func);
 201
 202     m->do_remap = NULL;
 203
 204     /* call the installed remap init function */
 205     init_remap_func(m);
 206
 207     if (m->do_remap == NULL) {
 208         /* nothing was installed, fallback to C version */
 209         init_remap_c(m);
 210     }
 211 }
 212
 213 pa_init_remap_func_t pa_get_init_remap_func(void) {
 214     return init_remap_func;
 215 }
 216
 217 void pa_set_init_remap_func(pa_init_remap_func_t func) {
 218     init_remap_func = func;
 219 }