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 "sample-util.h"
  32
  33 struct pa_memblock *pa_silence_memblock(struct pa_memblock* b, const struct pa_sample_spec *spec) {
  34     assert(b && b->data && spec);
  35     pa_silence_memory(b->data, b->length, spec);
  36     return b;
  37 }
  38
  39 void pa_silence_memchunk(struct pa_memchunk *c, const struct pa_sample_spec *spec) {
  40     assert(c && c->memblock && c->memblock->data && spec && c->length);
  41     pa_silence_memory((uint8_t*) c->memblock->data+c->index, c->length, spec);
  42 }
  43
  44 void pa_silence_memory(void *p, size_t length, const struct pa_sample_spec *spec) {
  45     uint8_t c = 0;
  46     assert(p && length && spec);
  47
  48     switch (spec->format) {
  49         case PA_SAMPLE_U8:
  50             c = 0x80;
  51             break;
  52         case PA_SAMPLE_S16LE:
  53         case PA_SAMPLE_S16BE:
  54         case PA_SAMPLE_FLOAT32:
  55             c = 0;
  56             break;
  57         case PA_SAMPLE_ALAW:
  58         case PA_SAMPLE_ULAW:
  59             c = 80;
  60             break;
  61         default:
  62             assert(0);
  63     }
  64
  65     memset(p, c, length);
  66 }
  67
  68 size_t pa_mix(struct pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const struct pa_sample_spec *spec, pa_volume_t volume) {
  69     assert(channels && data && length && spec);
  70
  71     if (spec->format == PA_SAMPLE_S16NE) {
  72         size_t d;
  73
  74         for (d = 0;; d += sizeof(int16_t)) {
  75             unsigned c;
  76             int32_t sum = 0;
  77
  78             if (d >= length)
  79                 return d;
  80
  81             for (c = 0; c < nchannels; c++) {
  82                 int32_t v;
  83                 pa_volume_t cvolume = channels[c].volume;
  84
  85                 if (d >= channels[c].chunk.length)
  86                     return d;
  87
  88                 if (cvolume == PA_VOLUME_MUTED)
  89                     v = 0;
  90                 else {
  91                     v = *((int16_t*) ((uint8_t*) channels[c].chunk.memblock->data + channels[c].chunk.index + d));
  92
  93                     if (cvolume != PA_VOLUME_NORM) {
  94                         v *= cvolume;
  95                         v /= PA_VOLUME_NORM;
  96                     }
  97                 }
  98
  99                 sum += v;
 100             }
 101
 102             if (volume == PA_VOLUME_MUTED)
 103                 sum = 0;
 104             else if (volume != PA_VOLUME_NORM) {
 105                 sum *= volume;
 106                 sum /= PA_VOLUME_NORM;
 107             }
 108
 109             if (sum < -0x8000) sum = -0x8000;
 110             if (sum > 0x7FFF) sum = 0x7FFF;
 111
 112             *((int16_t*) data) = sum;
 113             data = (uint8_t*) data + sizeof(int16_t);
 114         }
 115     } else if (spec->format == PA_SAMPLE_U8) {
 116         size_t d;
 117
 118         for (d = 0;; d ++) {
 119             int32_t sum = 0;
 120             unsigned c;
 121
 122             if (d >= length)
 123                 return d;
 124
 125             for (c = 0; c < nchannels; c++) {
 126                 int32_t v;
 127                 pa_volume_t cvolume = channels[c].volume;
 128
 129                 if (d >= channels[c].chunk.length)
 130                     return d;
 131
 132                 if (cvolume == PA_VOLUME_MUTED)
 133                     v = 0;
 134                 else {
 135                     v = (int32_t) *((uint8_t*) channels[c].chunk.memblock->data + channels[c].chunk.index + d) - 0x80;
 136
 137                     if (cvolume != PA_VOLUME_NORM) {
 138                         v *= cvolume;
 139                         v /= PA_VOLUME_NORM;
 140                     }
 141                 }
 142
 143                 sum += v;
 144             }
 145
 146             if (volume == PA_VOLUME_MUTED)
 147                 sum = 0;
 148             else if (volume != PA_VOLUME_NORM) {
 149                 sum *= volume;
 150                 sum /= PA_VOLUME_NORM;
 151             }
 152
 153             if (sum < -0x80) sum = -0x80;
 154             if (sum > 0x7F) sum = 0x7F;
 155
 156             *((uint8_t*) data) = (uint8_t) (sum + 0x80);
 157             data = (uint8_t*) data + 1;
 158         }
 159
 160     } else if (spec->format == PA_SAMPLE_FLOAT32NE) {
 161         size_t d;
 162
 163         for (d = 0;; d += sizeof(float)) {
 164             float_t sum = 0;
 165             unsigned c;
 166
 167             if (d >= length)
 168                 return d;
 169
 170             for (c = 0; c < nchannels; c++) {
 171                 float v;
 172                 pa_volume_t cvolume = channels[c].volume;
 173
 174                 if (d >= channels[c].chunk.length)
 175                     return d;
 176
 177                 if (cvolume == PA_VOLUME_MUTED)
 178                     v = 0;
 179                 else {
 180                     v = *((float*) ((uint8_t*) channels[c].chunk.memblock->data + channels[c].chunk.index + d));
 181
 182                     if (cvolume != PA_VOLUME_NORM)
 183                         v = v*cvolume/PA_VOLUME_NORM;
 184                 }
 185
 186                 sum += v;
 187             }
 188
 189             if (volume == PA_VOLUME_MUTED)
 190                 sum = 0;
 191             else if (volume != PA_VOLUME_NORM)
 192                 sum = sum*volume/PA_VOLUME_NORM;
 193
 194             if (sum < -1) sum = -1;
 195             if (sum > 1) sum = 1;
 196
 197             *((float*) data) = sum;
 198             data = (uint8_t*) data + sizeof(float);
 199         }
 200     } else {
 201         abort();
 202     }
 203 }
 204
 205
 206 void pa_volume_memchunk(struct pa_memchunk*c, const struct pa_sample_spec *spec, pa_volume_t volume) {
 207     assert(c && spec && (c->length % pa_frame_size(spec) == 0));
 208
 209     if (volume == PA_VOLUME_NORM)
 210         return;
 211
 212     if (volume == PA_VOLUME_MUTED) {
 213         pa_silence_memchunk(c, spec);
 214         return;
 215     }
 216
 217     if (spec->format == PA_SAMPLE_S16NE) {
 218         int16_t *d;
 219         size_t n;
 220
 221         for (d = (int16_t*) ((uint8_t*) c->memblock->data+c->index), n = c->length/sizeof(int16_t); n > 0; d++, n--) {
 222             int32_t t = (int32_t)(*d);
 223
 224             t *= volume;
 225             t /= PA_VOLUME_NORM;
 226
 227             if (t < -0x8000) t = -0x8000;
 228             if (t > 0x7FFF) t = 0x7FFF;
 229
 230             *d = (int16_t) t;
 231         }
 232     } else if (spec->format == PA_SAMPLE_U8) {
 233         uint8_t *d;
 234         size_t n;
 235
 236         for (d = (uint8_t*) c->memblock->data + c->index, n = c->length; n > 0; d++, n--) {
 237             int32_t t = (int32_t) *d - 0x80;
 238
 239             t *= volume;
 240             t /= PA_VOLUME_NORM;
 241
 242             if (t < -0x80) t = -0x80;
 243             if (t > 0x7F) t = 0x7F;
 244
 245             *d = (uint8_t) (t + 0x80);
 246
 247         }
 248     } else if (spec->format == PA_SAMPLE_FLOAT32NE) {
 249         float *d;
 250         size_t n;
 251
 252         for (d = (float*) ((uint8_t*) c->memblock->data+c->index), n = c->length/sizeof(float); n > 0; d++, n--) {
 253             float t = *d;
 254
 255             t *= volume;
 256             t /= PA_VOLUME_NORM;
 257
 258             if (t < -1) t = -1;
 259             if (t > 1) t = 1;
 260
 261             *d = t;
 262         }
 263
 264     } else {
 265         abort();
 266     }
 267 }
 268