556a3db1 |
1 | /* |
2 | * Copyright (C) 2013 nu774 |
3 | * For conditions of distribution and use, see copyright notice in COPYING |
4 | */ |
4d48b091 |
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 | } |