src/extrapolater.c

   1 #if HAVE_CONFIG_H
   2 #  include "config.h"
   3 #endif
   4 #if HAVE_STDINT_H
   5 #  include <stdint.h>
   6 #endif
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <assert.h>
  10 #include "pcm_reader.h"
  11 #include "lpc.h"
  12
  13 typedef int16_t sample_t;
  14
  15 typedef struct buffer_t {
  16     sample_t *data;
  17     unsigned count;    /* count in frames */
  18     unsigned capacity; /* size in bytes   */
  19 } buffer_t;
  20
  21 typedef struct extrapolater_t {
  22     pcm_reader_vtbl_t *vtbl;
  23     pcm_reader_t *src;
  24     pcm_sample_description_t format;
  25     buffer_t buffer[2];
  26     unsigned nbuffer;
  27     int (*process)(struct extrapolater_t *, void *, unsigned);
  28 } extrapolater_t;
  29
  30 #define LPC_ORDER 32
  31
  32 static inline pcm_reader_t *get_source(pcm_reader_t *reader)
  33 {
  34     return ((extrapolater_t *)reader)->src;
  35 }
  36
  37 static const
  38 pcm_sample_description_t *get_format(pcm_reader_t *reader)
  39 {
  40     return pcm_get_format(get_source(reader));
  41 }
  42
  43 static int64_t get_length(pcm_reader_t *reader)
  44 {
  45     return pcm_get_length(get_source(reader));
  46 }
  47
  48 static int64_t get_position(pcm_reader_t *reader)
  49 {
  50     return pcm_get_position(get_source(reader));
  51 }
  52
  53 static int realloc_buffer(buffer_t *bp, size_t size)
  54 {
  55     if (bp->capacity < size) {
  56         void *p = realloc(bp->data, size);
  57         if (!p) return -1;
  58         bp->data = p;
  59         bp->capacity = size;
  60     }
  61     return 0;
  62 }
  63
  64 static void reverse_buffer(sample_t *data, unsigned nframes, unsigned nchannels)
  65 {
  66     unsigned i = 0, j = nchannels * (nframes - 1), n;
  67
  68     for (; i < j; i += nchannels, j -= nchannels) {
  69         for (n = 0; n < nchannels; ++n) {
  70             sample_t tmp = data[i + n];
  71             data[i + n] = data[j + n];
  72             data[j + n] = tmp;
  73         }
  74     }
  75 }
  76
  77 static int fetch(extrapolater_t *self, unsigned nframes)
  78 {
  79     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
  80     buffer_t *bp = &self->buffer[self->nbuffer];
  81     int rc = 0;
  82
  83     if (realloc_buffer(bp, nframes * sfmt->bytes_per_frame) == 0) {
  84         rc = pcm_read_frames(self->src, bp->data, nframes);
  85         bp->count = rc > 0 ? rc : 0;
  86     }
  87     if (rc > 0)
  88         self->nbuffer ^= 1;
  89     return bp->count;
  90 }
  91
  92 static int extrapolate(extrapolater_t *self, const buffer_t *bp,
  93                         void *dst, unsigned nframes)
  94 {
  95     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
  96     unsigned i, n = sfmt->channels_per_frame;
  97     float lpc[LPC_ORDER];
  98
  99     for (i = 0; i < n; ++i) {
 100         vorbis_lpc_from_data(bp->data + i, lpc, bp->count, LPC_ORDER, n);
 101         vorbis_lpc_predict(lpc, &bp->data[i + n * (bp->count - LPC_ORDER)],
 102                            LPC_ORDER, (sample_t*)dst + i, nframes, n);
 103     }
 104     return nframes;
 105 }
 106
 107 static int process1(extrapolater_t *self, void *buffer, unsigned nframes);
 108 static int process2(extrapolater_t *self, void *buffer, unsigned nframes);
 109 static int process3(extrapolater_t *self, void *buffer, unsigned nframes);
 110
 111 static int process0(extrapolater_t *self, void *buffer, unsigned nframes)
 112 {
 113     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
 114     unsigned nchannels = sfmt->channels_per_frame;
 115     buffer_t *bp = &self->buffer[self->nbuffer];
 116
 117     if (fetch(self, nframes) < 2 * LPC_ORDER)
 118         memset(buffer, 0, nframes * sfmt->bytes_per_frame);
 119     else {
 120         reverse_buffer(bp->data, bp->count, nchannels);
 121         extrapolate(self, bp, buffer, nframes);
 122         reverse_buffer(buffer, nframes, nchannels);
 123         reverse_buffer(bp->data, bp->count, nchannels);
 124     }
 125     self->process = bp->count ? process1 : process2;
 126     return nframes;
 127 }
 128
 129 static int process1(extrapolater_t *self, void *buffer, unsigned nframes)
 130 {
 131     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
 132     buffer_t *bp = &self->buffer[self->nbuffer ^ 1];
 133
 134     assert(bp->count <= nframes);
 135     memcpy(buffer, bp->data, bp->count * sfmt->bytes_per_frame);
 136     if (!fetch(self, nframes))
 137         self->process = process2;
 138     return bp->count;
 139 }
 140
 141 static int process2(extrapolater_t *self, void *buffer, unsigned nframes)
 142 {
 143     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
 144     buffer_t *bp = &self->buffer[self->nbuffer];
 145     buffer_t *bbp = &self->buffer[self->nbuffer ^ 1];
 146
 147     if (bp->count < 2 * LPC_ORDER) {
 148         size_t total = bp->count + bbp->count;
 149         if (bbp->count &&
 150             realloc_buffer(bbp, total * sfmt->bytes_per_frame) == 0)
 151         {
 152             memcpy(bbp->data + bbp->count * sfmt->channels_per_frame,
 153                    bp->data, bp->count * sfmt->bytes_per_frame);
 154             bbp->count = total;
 155             bp->count = 0;
 156             bp = bbp;
 157             self->nbuffer ^= 1;
 158         }
 159     }
 160     self->process = process3;
 161
 162     if (bp->count >= 2 * LPC_ORDER)
 163         extrapolate(self, bp, buffer, nframes);
 164     else
 165         memset(buffer, 0, nframes * sfmt->bytes_per_frame);
 166     return nframes;
 167 }
 168
 169 static int process3(extrapolater_t *self, void *buffer, unsigned nframes)
 170 {
 171     return 0;
 172 }
 173
 174 static int read_frames(pcm_reader_t *reader, void *buffer, unsigned nframes)
 175 {
 176     extrapolater_t *self = (extrapolater_t *)reader;
 177     return self->process(self, buffer, nframes);
 178 }
 179
 180 static void teardown(pcm_reader_t **reader)
 181 {
 182     extrapolater_t *self = (extrapolater_t *)*reader;
 183     pcm_teardown(&self->src);
 184     free(self->buffer[0].data);
 185     free(self->buffer[1].data);
 186     free(self);
 187     *reader = 0;
 188 }
 189
 190 static pcm_reader_vtbl_t my_vtable = {
 191     get_format, get_length, get_position, read_frames, teardown
 192 };
 193
 194 pcm_reader_t *extrapolater_open(pcm_reader_t *reader)
 195 {
 196     extrapolater_t *self = 0;
 197
 198     if ((self = calloc(1, sizeof(extrapolater_t))) == 0)
 199         return 0;
 200     self->src = reader;
 201     self->vtbl = &my_vtable;
 202     self->process = process0;
 203     return (pcm_reader_t *)self;
 204 }