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         if (rc > 0) bp->count = rc;
  90     }
  91     if (rc > 0)
  92         self->nbuffer ^= 1;
  93     return rc <= 0 ? 0 : 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         buffer_t *bbp = &self->buffer[self->nbuffer];
 142         if (bp->count < 2 * LPC_ORDER) {
 143             size_t total = bp->count + bbp->count;
 144             if (bbp->count &&
 145                 realloc_buffer(bbp, total * sfmt->bytes_per_frame) == 0 &&
 146                 realloc_buffer(bp, total * sfmt->bytes_per_frame) == 0)
 147             {
 148                 memcpy(bbp->data + bbp->count * sfmt->channels_per_frame,
 149                        bp->data, bp->count * sfmt->bytes_per_frame);
 150                 memcpy(bp->data, bbp->data, total * sfmt->bytes_per_frame);
 151                 bp->count = total;
 152             }
 153         }
 154         if (bp->count >= 2 * LPC_ORDER)
 155             extrapolate(self, bp, bbp->data, nframes);
 156         else
 157             memset(bbp->data, 0, nframes * sfmt->bytes_per_frame);
 158         bbp->count = nframes;
 159         self->process = process2;
 160     }
 161     return bp->count;
 162 }
 163
 164 static int process2(extrapolater_t *self, void *buffer, unsigned nframes)
 165 {
 166     const pcm_sample_description_t *sfmt = pcm_get_format(self->src);
 167     buffer_t *bp = &self->buffer[self->nbuffer];
 168     if (bp->count < nframes)
 169         nframes = bp->count;
 170     memcpy(buffer, bp->data, nframes * sfmt->bytes_per_frame);
 171     if (bp->count > nframes)
 172         memmove(bp->data, bp->data + nframes * sfmt->channels_per_frame,
 173                 (bp->count - nframes) * sfmt->bytes_per_frame);
 174     bp->count -= nframes;
 175     if (bp->count == 0)
 176         self->process = process3;
 177     return nframes;
 178 }
 179
 180 static int process3(extrapolater_t *self, void *buffer, unsigned nframes)
 181 {
 182     return 0;
 183 }
 184
 185 static int read_frames(pcm_reader_t *reader, void *buffer, unsigned nframes)
 186 {
 187     extrapolater_t *self = (extrapolater_t *)reader;
 188     return self->process(self, buffer, nframes);
 189 }
 190
 191 static void teardown(pcm_reader_t **reader)
 192 {
 193     extrapolater_t *self = (extrapolater_t *)*reader;
 194     pcm_teardown(&self->src);
 195     free(self->buffer[0].data);
 196     free(self->buffer[1].data);
 197     free(self);
 198     *reader = 0;
 199 }
 200
 201 static pcm_reader_vtbl_t my_vtable = {
 202     get_format, get_length, get_position, read_frames, teardown
 203 };
 204
 205 pcm_reader_t *extrapolater_open(pcm_reader_t *reader)
 206 {
 207     extrapolater_t *self = 0;
 208
 209     if ((self = calloc(1, sizeof(extrapolater_t))) == 0)
 210         return 0;
 211     self->src = reader;
 212     self->vtbl = &my_vtable;
 213     self->process = process0;
 214     return (pcm_reader_t *)self;
 215 }