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

   1 #include <string.h>
   2 #include <assert.h>
   3
   4 #include "sample.h"
   5
   6 struct sample_spec default_sample_spec = {
   7     .format = SAMPLE_S16NE,
   8     .rate = 44100,
   9     .channels = 2
  10 };
  11
  12 struct memblock *silence_memblock(struct memblock* b, struct 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 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 sample_spec *spec) {
  26     char c = 0;
  27     assert(p && length && spec);
  28
  29     switch (spec->format) {
  30         case SAMPLE_U8:
  31             c = 127;
  32             break;
  33         case SAMPLE_S16LE:
  34         case SAMPLE_S16BE:
  35         case SAMPLE_FLOAT32:
  36             c = 0;
  37             break;
  38         case SAMPLE_ALAW:
  39         case SAMPLE_ULAW:
  40             c = 80;
  41             break;
  42     }
  43
  44     memset(p, c, length);
  45 }
  46
  47 size_t sample_size(struct sample_spec *spec) {
  48     assert(spec);
  49     size_t b = 1;
  50
  51     switch (spec->format) {
  52         case SAMPLE_U8:
  53         case SAMPLE_ULAW:
  54         case SAMPLE_ALAW:
  55             b = 1;
  56             break;
  57         case SAMPLE_S16LE:
  58         case SAMPLE_S16BE:
  59             b = 2;
  60             break;
  61         case SAMPLE_FLOAT32:
  62             b = 4;
  63             break;
  64     }
  65
  66     return b * spec->channels;
  67 }
  68
  69 size_t bytes_per_second(struct sample_spec *spec) {
  70     assert(spec);
  71     return spec->rate*sample_size(spec);
  72 }
  73
  74 size_t mix_chunks(struct mix_info channels[], unsigned nchannels, void *data, size_t length, struct sample_spec *spec, uint8_t volume) {
  75     unsigned c, d;
  76     assert(channels && data && length && spec);
  77     assert(spec->format == SAMPLE_S16NE);
  78
  79     for (d = 0;; d += sizeof(int16_t)) {
  80         int32_t sum = 0;
  81
  82         if (d >= length)
  83             return d;
  84
  85         for (c = 0; c < nchannels; c++) {
  86             int32_t v;
  87             uint8_t volume = channels[c].volume;
  88
  89             if (d >= channels[c].chunk.length)
  90                 return d;
  91
  92             if (volume == 0)
  93                 v = 0;
  94             else {
  95                 v = *((int16_t*) (channels[c].chunk.memblock->data + channels[c].chunk.index + d));
  96
  97                 if (volume != 0xFF)
  98                     v = v*volume/0xFF;
  99             }
 100
 101             sum += v;
 102         }
 103
 104         if (volume == 0)
 105             sum = 0;
 106         else if (volume != 0xFF)
 107             sum = sum*volume/0xFF;
 108
 109         if (sum < -0x8000) sum = -0x8000;
 110         if (sum > 0x7FFF) sum = 0x7FFF;
 111
 112         *((int16_t*) data) = sum;
 113         data += sizeof(int16_t);
 114     }
 115 }
 116
 117 uint32_t samples_usec(size_t length, struct sample_spec *spec) {
 118     assert(spec);
 119
 120     return (uint32_t) (((double) length /sample_size(spec))/spec->rate*1000000);
 121 }