src/sample-util.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <assert.h>
   4
   5 #include "sample-util.h"
   6
   7 struct pa_memblock *pa_silence_memblock(struct pa_memblock* b, const struct pa_sample_spec *spec) {
   8     assert(b && b->data && spec);
   9     pa_silence_memory(b->data, b->length, spec);
  10     return b;
  11 }
  12
  13 void pa_silence_memchunk(struct pa_memchunk *c, const struct pa_sample_spec *spec) {
  14     assert(c && c->memblock && c->memblock->data && spec && c->length);
  15     pa_silence_memory(c->memblock->data+c->index, c->length, spec);
  16 }
  17
  18 void pa_silence_memory(void *p, size_t length, const struct pa_sample_spec *spec) {
  19     char c = 0;
  20     assert(p && length && spec);
  21
  22     switch (spec->format) {
  23         case PA_SAMPLE_U8:
  24             c = 127;
  25             break;
  26         case PA_SAMPLE_S16LE:
  27         case PA_SAMPLE_S16BE:
  28         case PA_SAMPLE_FLOAT32:
  29             c = 0;
  30             break;
  31         case PA_SAMPLE_ALAW:
  32         case PA_SAMPLE_ULAW:
  33             c = 80;
  34             break;
  35         default:
  36             assert(0);
  37     }
  38
  39     memset(p, c, length);
  40 }
  41
  42 size_t pa_mix(struct pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const struct pa_sample_spec *spec, uint32_t volume) {
  43     unsigned c, d;
  44     assert(channels && data && length && spec);
  45     assert(spec->format == PA_SAMPLE_S16NE);
  46
  47     for (d = 0;; d += sizeof(int16_t)) {
  48         int32_t sum = 0;
  49
  50         if (d >= length)
  51             return d;
  52
  53         for (c = 0; c < nchannels; c++) {
  54             int32_t v;
  55             uint32_t volume = channels[c].volume;
  56
  57             if (d >= channels[c].chunk.length)
  58                 return d;
  59
  60             if (volume == PA_VOLUME_MUTE)
  61                 v = 0;
  62             else {
  63                 v = *((int16_t*) (channels[c].chunk.memblock->data + channels[c].chunk.index + d));
  64
  65                 if (volume != PA_VOLUME_NORM)
  66                     v = (int32_t) ((float)v*volume/PA_VOLUME_NORM);
  67             }
  68
  69             sum += v;
  70         }
  71
  72         if (volume == PA_VOLUME_MUTE)
  73             sum = 0;
  74         else if (volume != PA_VOLUME_NORM)
  75             sum = (int32_t) ((float) sum*volume/PA_VOLUME_NORM);
  76
  77         if (sum < -0x8000) sum = -0x8000;
  78         if (sum > 0x7FFF) sum = 0x7FFF;
  79
  80         *((int16_t*) data) = sum;
  81         data += sizeof(int16_t);
  82     }
  83 }
  84
  85
  86 void pa_volume_memchunk(struct pa_memchunk*c, const struct pa_sample_spec *spec, uint32_t volume) {
  87     int16_t *d;
  88     size_t n;
  89     assert(c && spec && (c->length % pa_sample_size(spec) == 0));
  90     assert(spec->format == PA_SAMPLE_S16NE);
  91
  92     if (volume == PA_VOLUME_NORM)
  93         return;
  94
  95     if (volume == PA_VOLUME_MUTE) {
  96         pa_silence_memchunk(c, spec);
  97         return;
  98     }
  99
 100     for (d = (c->memblock->data+c->index), n = c->length/sizeof(int16_t); n > 0; d++, n--) {
 101         int32_t t = (int32_t)(*d);
 102
 103         t *= volume;
 104         t /= PA_VOLUME_NORM;
 105
 106         if (t < -0x8000) t = -0x8000;
 107         if (t > 0x7FFF) t = 0x7FFF;
 108
 109         *d = (int16_t) t;
 110     }
 111 }
 112
 113 uint32_t pa_volume_multiply(uint32_t a, uint32_t b) {
 114     uint64_t p = a;
 115     p *= b;
 116     p /= PA_VOLUME_NORM;
 117
 118     return (uint32_t) p;
 119 }