code.delx.au - pulseaudio/blob - src/sample-util.c

   1 #include <string.h>
   2 #include <assert.h>
   3
   4 #include "sample-util.h"
   5
   6 struct pa_sample_spec default_sample_spec = {
   7     .format = PA_SAMPLE_S16NE,
   8     .rate = 44100,
   9     .channels = 2
  10 };
  11
  12 struct memblock *silence_memblock(struct memblock* b, struct pa_sample_spec *spec) {
  13     assert(b && b->data && spec);
  14     memblock_assert_exclusive(b);
  15     silence_memory(b->data, b->length, spec);
  16     return b;
  17 }
  18
  19 void silence_memchunk(struct memchunk *c, struct pa_sample_spec *spec) {
  20     assert(c && c->memblock && c->memblock->data && spec && c->length);
  21     memblock_assert_exclusive(c->memblock);
  22     silence_memory(c->memblock->data+c->index, c->length, spec);
  23 }
  24
  25 void silence_memory(void *p, size_t length, struct pa_sample_spec *spec) {
  26     char c = 0;
  27     assert(p && length && spec);
  28
  29     switch (spec->format) {
  30         case PA_SAMPLE_U8:
  31             c = 127;
  32             break;
  33         case PA_SAMPLE_S16LE:
  34         case PA_SAMPLE_S16BE:
  35         case PA_SAMPLE_FLOAT32:
  36             c = 0;
  37             break;
  38         case PA_SAMPLE_ALAW:
  39         case PA_SAMPLE_ULAW:
  40             c = 80;
  41             break;
  42         default:
  43             assert(0);
  44     }
  45
  46     memset(p, c, length);
  47 }
  48
  49 size_t mix_chunks(struct mix_info channels[], unsigned nchannels, void *data, size_t length, struct pa_sample_spec *spec, uint8_t volume) {
  50     unsigned c, d;
  51     assert(channels && data && length && spec);
  52     assert(spec->format == PA_SAMPLE_S16NE);
  53
  54     for (d = 0;; d += sizeof(int16_t)) {
  55         int32_t sum = 0;
  56
  57         if (d >= length)
  58             return d;
  59
  60         for (c = 0; c < nchannels; c++) {
  61             int32_t v;
  62             uint8_t volume = channels[c].volume;
  63
  64             if (d >= channels[c].chunk.length)
  65                 return d;
  66
  67             if (volume == 0)
  68                 v = 0;
  69             else {
  70                 v = *((int16_t*) (channels[c].chunk.memblock->data + channels[c].chunk.index + d));
  71
  72                 if (volume != 0xFF)
  73                     v = v*volume/0xFF;
  74             }
  75
  76             sum += v;
  77         }
  78
  79         if (volume == 0)
  80             sum = 0;
  81         else if (volume != 0xFF)
  82             sum = sum*volume/0xFF;
  83
  84         if (sum < -0x8000) sum = -0x8000;
  85         if (sum > 0x7FFF) sum = 0x7FFF;
  86
  87         *((int16_t*) data) = sum;
  88         data += sizeof(int16_t);
  89     }
  90 }