code.delx.au - pulseaudio/blob - polyp/sample-util.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 Lesser 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 Lesser 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 <stdio.h>
  27 #include <string.h>
  28 #include <assert.h>
  29 #include <stdlib.h>
  30
  31 #include <liboil/liboilfuncs.h>
  32
  33 #include "log.h"
  34 #include "sample-util.h"
  35
  36 pa_memblock *pa_silence_memblock(pa_memblock* b, const pa_sample_spec *spec) {
  37     assert(b && b->data && spec);
  38     pa_silence_memory(b->data, b->length, spec);
  39     return b;
  40 }
  41
  42 void pa_silence_memchunk(pa_memchunk *c, const pa_sample_spec *spec) {
  43     assert(c && c->memblock && c->memblock->data && spec && c->length);
  44
  45     pa_silence_memory((uint8_t*) c->memblock->data+c->index, c->length, spec);
  46 }
  47
  48 void pa_silence_memory(void *p, size_t length, const pa_sample_spec *spec) {
  49     uint8_t c = 0;
  50     assert(p && length && spec);
  51
  52     switch (spec->format) {
  53         case PA_SAMPLE_U8:
  54             c = 0x80;
  55             break;
  56         case PA_SAMPLE_S16LE:
  57         case PA_SAMPLE_S16BE:
  58         case PA_SAMPLE_FLOAT32:
  59             c = 0;
  60             break;
  61         case PA_SAMPLE_ALAW:
  62         case PA_SAMPLE_ULAW:
  63             c = 80;
  64             break;
  65         default:
  66             assert(0);
  67     }
  68
  69     memset(p, c, length);
  70 }
  71
  72 size_t pa_mix(
  73     const pa_mix_info streams[],
  74     unsigned nstreams,
  75     void *data,
  76     size_t length,
  77     const pa_sample_spec *spec,
  78     const pa_cvolume *volume) {
  79
  80     assert(streams && data && length && spec);
  81
  82     switch (spec->format) {
  83         case PA_SAMPLE_S16NE:{
  84             size_t d;
  85             unsigned channel = 0;
  86
  87             for (d = 0;; d += sizeof(int16_t)) {
  88                 int32_t sum = 0;
  89
  90                 if (d >= length)
  91                     return d;
  92
  93                 if (volume->values[channel] != PA_VOLUME_MUTED) {
  94                     unsigned i;
  95
  96                     for (i = 0; i < nstreams; i++) {
  97                         int32_t v;
  98                         pa_volume_t cvolume = streams[i].volume.values[channel];
  99
 100                         if (d >= streams[i].chunk.length)
 101                             return d;
 102
 103                         if (cvolume == PA_VOLUME_MUTED)
 104                             v = 0;
 105                         else {
 106                             v = *((int16_t*) ((uint8_t*) streams[i].chunk.memblock->data + streams[i].chunk.index + d));
 107
 108                             if (cvolume != PA_VOLUME_NORM) {
 109                                 v *= cvolume;
 110                                 v /= PA_VOLUME_NORM;
 111                             }
 112                         }
 113
 114                         sum += v;
 115                     }
 116
 117                     if (volume->values[channel] != PA_VOLUME_NORM) {
 118                         sum *= volume->values[channel];
 119                         sum /= PA_VOLUME_NORM;
 120                     }
 121
 122                     if (sum < -0x8000) sum = -0x8000;
 123                     if (sum > 0x7FFF) sum = 0x7FFF;
 124
 125                 }
 126
 127                 *((int16_t*) data) = sum;
 128                 data = (uint8_t*) data + sizeof(int16_t);
 129
 130                 if (++channel >= spec->channels)
 131                     channel = 0;
 132             }
 133         }
 134
 135         case PA_SAMPLE_U8: {
 136             size_t d;
 137             unsigned channel = 0;
 138
 139             for (d = 0;; d ++) {
 140                 int32_t sum = 0;
 141
 142                 if (d >= length)
 143                     return d;
 144
 145                 if (volume->values[channel] != PA_VOLUME_MUTED) {
 146                     unsigned i;
 147
 148                     for (i = 0; i < nstreams; i++) {
 149                         int32_t v;
 150                         pa_volume_t cvolume = streams[i].volume.values[channel];
 151
 152                         if (d >= streams[i].chunk.length)
 153                             return d;
 154
 155                         if (cvolume == PA_VOLUME_MUTED)
 156                             v = 0;
 157                         else {
 158                             v = (int32_t) *((uint8_t*) streams[i].chunk.memblock->data + streams[i].chunk.index + d) - 0x80;
 159
 160                             if (cvolume != PA_VOLUME_NORM) {
 161                                 v *= cvolume;
 162                                 v /= PA_VOLUME_NORM;
 163                             }
 164                         }
 165
 166                         sum += v;
 167                     }
 168
 169                     if (volume->values[channel] != PA_VOLUME_NORM) {
 170                         sum *= volume->values[channel];
 171                         sum /= PA_VOLUME_NORM;
 172                     }
 173
 174                     if (sum < -0x80) sum = -0x80;
 175                     if (sum > 0x7F) sum = 0x7F;
 176
 177                 }
 178
 179                 *((uint8_t*) data) = (uint8_t) (sum + 0x80);
 180                 data = (uint8_t*) data + 1;
 181
 182                 if (++channel >= spec->channels)
 183                     channel = 0;
 184             }
 185         }
 186
 187         case PA_SAMPLE_FLOAT32NE: {
 188             size_t d;
 189             unsigned channel = 0;
 190
 191             for (d = 0;; d += sizeof(float)) {
 192                 float sum = 0;
 193
 194                 if (d >= length)
 195                     return d;
 196
 197                 if (volume->values[channel] != PA_VOLUME_MUTED) {
 198                     unsigned i;
 199
 200                     for (i = 0; i < nstreams; i++) {
 201                         float v;
 202                         pa_volume_t cvolume = streams[i].volume.values[channel];
 203
 204                         if (d >= streams[i].chunk.length)
 205                             return d;
 206
 207                         if (cvolume == PA_VOLUME_MUTED)
 208                             v = 0;
 209                         else {
 210                             v = *((float*) ((uint8_t*) streams[i].chunk.memblock->data + streams[i].chunk.index + d));
 211
 212                             if (cvolume != PA_VOLUME_NORM) {
 213                                 v *= cvolume;
 214                                 v /= PA_VOLUME_NORM;
 215                             }
 216                         }
 217
 218                         sum += v;
 219                     }
 220
 221                     if (volume->values[channel] != PA_VOLUME_NORM) {
 222                         sum *= volume->values[channel];
 223                         sum /= PA_VOLUME_NORM;
 224                     }
 225                 }
 226
 227                 *((float*) data) = sum;
 228                 data = (uint8_t*) data + sizeof(float);
 229
 230                 if (++channel >= spec->channels)
 231                     channel = 0;
 232             }
 233         }
 234
 235         default:
 236             abort();
 237     }
 238 }
 239
 240
 241 void pa_volume_memchunk(pa_memchunk*c, const pa_sample_spec *spec, const pa_cvolume *volume) {
 242     assert(c && spec && (c->length % pa_frame_size(spec) == 0));
 243     assert(volume);
 244
 245     if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_NORM))
 246         return;
 247
 248     if (pa_cvolume_channels_equal_to(volume, PA_VOLUME_MUTED)) {
 249         pa_silence_memchunk(c, spec);
 250         return;
 251     }
 252
 253     switch (spec->format) {
 254         case PA_SAMPLE_S16NE: {
 255             int16_t *d;
 256             size_t n;
 257             unsigned channel = 0;
 258
 259             for (d = (int16_t*) ((uint8_t*) c->memblock->data+c->index), n = c->length/sizeof(int16_t); n > 0; d++, n--) {
 260                 int32_t t = (int32_t)(*d);
 261
 262                 t *= volume->values[channel];
 263                 t /= PA_VOLUME_NORM;
 264
 265                 if (t < -0x8000) t = -0x8000;
 266                 if (t > 0x7FFF) t = 0x7FFF;
 267
 268                 *d = (int16_t) t;
 269
 270                 if (++channel >= spec->channels)
 271                     channel = 0;
 272             }
 273             break;
 274         }
 275
 276         case PA_SAMPLE_U8: {
 277             uint8_t *d;
 278             size_t n;
 279             unsigned channel = 0;
 280
 281             for (d = (uint8_t*) c->memblock->data + c->index, n = c->length; n > 0; d++, n--) {
 282                 int32_t t = (int32_t) *d - 0x80;
 283
 284                 t *= volume->values[channel];
 285                 t /= PA_VOLUME_NORM;
 286
 287                 if (t < -0x80) t = -0x80;
 288                 if (t > 0x7F) t = 0x7F;
 289
 290                 *d = (uint8_t) (t + 0x80);
 291
 292                 if (++channel >= spec->channels)
 293                     channel = 0;
 294             }
 295             break;
 296         }
 297
 298         case PA_SAMPLE_FLOAT32NE: {
 299             float *d;
 300             int skip;
 301             unsigned n;
 302             unsigned channel;
 303
 304             d = (float*) ((uint8_t*) c->memblock->data + c->index);
 305             skip = spec->channels * sizeof(float);
 306             n = c->length/sizeof(float)/spec->channels;
 307
 308             for (channel = 0; channel < spec->channels ; channel ++) {
 309                 float v, *t;
 310
 311                 if (volume->values[channel] == PA_VOLUME_NORM)
 312                     continue;
 313
 314                 v = (float) volume->values[channel] / PA_VOLUME_NORM;
 315
 316                 t = d + channel;
 317                 oil_scalarmult_f32(t, skip, t, skip, &v, n);
 318             }
 319             break;
 320         }
 321
 322         default:
 323             pa_log_error(__FILE__": ERROR: Unable to change volume of format %s.\n",
 324                 pa_sample_format_to_string(spec->format));
 325             abort();
 326     }
 327 }
 328