src/extrapolater.c

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