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); |
a7e00a42 |
89 | if (rc > 0) bp->count = rc; |
4d48b091 |
90 | } |
91 | if (rc > 0) |
92 | self->nbuffer ^= 1; |
a7e00a42 |
93 | return rc <= 0 ? 0 : bp->count; |
4d48b091 |
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); |
a7e00a42 |
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; |
4d48b091 |
159 | self->process = process2; |
a7e00a42 |
160 | } |
4d48b091 |
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]; |
a7e00a42 |
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; |
4d48b091 |
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 | } |