diff options
author | Sean Bartell <wingedtachikoma@gmail.com> | 2011-06-25 21:32:25 -0400 |
---|---|---|
committer | Nils Wallménius <nils@rockbox.org> | 2012-04-25 22:13:20 +0200 |
commit | f40bfc9267b13b54e6379dfe7539447662879d24 (patch) | |
tree | 9b20069d5e62809ff434061ad730096836f916f2 /lib/rbcodec/codecs/liba52/downmix.c | |
parent | a0009907de7a0107d49040d8a180f140e2eff299 (diff) | |
download | rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.tar.gz rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.zip |
Add codecs to librbcodec.
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97
Reviewed-on: http://gerrit.rockbox.org/137
Reviewed-by: Nils Wallménius <nils@rockbox.org>
Tested-by: Nils Wallménius <nils@rockbox.org>
Diffstat (limited to 'lib/rbcodec/codecs/liba52/downmix.c')
-rw-r--r-- | lib/rbcodec/codecs/liba52/downmix.c | 688 |
1 files changed, 688 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/liba52/downmix.c b/lib/rbcodec/codecs/liba52/downmix.c new file mode 100644 index 0000000000..dd2867cb92 --- /dev/null +++ b/lib/rbcodec/codecs/liba52/downmix.c | |||
@@ -0,0 +1,688 @@ | |||
1 | /* | ||
2 | * downmix.c | ||
3 | * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org> | ||
4 | * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca> | ||
5 | * | ||
6 | * This file is part of a52dec, a free ATSC A-52 stream decoder. | ||
7 | * See http://liba52.sourceforge.net/ for updates. | ||
8 | * | ||
9 | * a52dec is free software; you can redistribute it and/or modify | ||
10 | * it under the terms of the GNU General Public License as published by | ||
11 | * the Free Software Foundation; either version 2 of the License, or | ||
12 | * (at your option) any later version. | ||
13 | * | ||
14 | * a52dec is distributed in the hope that it will be useful, | ||
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
17 | * GNU General Public License for more details. | ||
18 | * | ||
19 | * You should have received a copy of the GNU General Public License | ||
20 | * along with this program; if not, write to the Free Software | ||
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | */ | ||
23 | |||
24 | #include "config-a52.h" | ||
25 | |||
26 | #include <string.h> | ||
27 | #include <inttypes.h> | ||
28 | |||
29 | #include "a52.h" | ||
30 | #include "a52_internal.h" | ||
31 | |||
32 | #define CONVERT(acmod,output) (((output) << 3) + (acmod)) | ||
33 | |||
34 | int a52_downmix_init (int input, int flags, level_t * level, | ||
35 | level_t clev, level_t slev) | ||
36 | { | ||
37 | static uint8_t table[11][8] = { | ||
38 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO, | ||
39 | A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO}, | ||
40 | {A52_MONO, A52_MONO, A52_MONO, A52_MONO, | ||
41 | A52_MONO, A52_MONO, A52_MONO, A52_MONO}, | ||
42 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO, | ||
43 | A52_STEREO, A52_STEREO, A52_STEREO, A52_STEREO}, | ||
44 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F, | ||
45 | A52_STEREO, A52_3F, A52_STEREO, A52_3F}, | ||
46 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO, | ||
47 | A52_2F1R, A52_2F1R, A52_2F1R, A52_2F1R}, | ||
48 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_STEREO, | ||
49 | A52_2F1R, A52_3F1R, A52_2F1R, A52_3F1R}, | ||
50 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F, | ||
51 | A52_2F2R, A52_2F2R, A52_2F2R, A52_2F2R}, | ||
52 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_3F, | ||
53 | A52_2F2R, A52_3F2R, A52_2F2R, A52_3F2R}, | ||
54 | {A52_CHANNEL1, A52_MONO, A52_MONO, A52_MONO, | ||
55 | A52_MONO, A52_MONO, A52_MONO, A52_MONO}, | ||
56 | {A52_CHANNEL2, A52_MONO, A52_MONO, A52_MONO, | ||
57 | A52_MONO, A52_MONO, A52_MONO, A52_MONO}, | ||
58 | {A52_CHANNEL, A52_DOLBY, A52_STEREO, A52_DOLBY, | ||
59 | A52_DOLBY, A52_DOLBY, A52_DOLBY, A52_DOLBY} | ||
60 | }; | ||
61 | int output; | ||
62 | |||
63 | output = flags & A52_CHANNEL_MASK; | ||
64 | if (output > A52_DOLBY) | ||
65 | return -1; | ||
66 | |||
67 | output = table[output][input & 7]; | ||
68 | |||
69 | if (output == A52_STEREO && | ||
70 | (input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB)))) | ||
71 | output = A52_DOLBY; | ||
72 | |||
73 | if (flags & A52_ADJUST_LEVEL) { | ||
74 | level_t adjust; | ||
75 | |||
76 | switch (CONVERT (input & 7, output)) { | ||
77 | |||
78 | case CONVERT (A52_3F, A52_MONO): | ||
79 | adjust = DIV (LEVEL_3DB, LEVEL (1) + clev); | ||
80 | break; | ||
81 | |||
82 | case CONVERT (A52_STEREO, A52_MONO): | ||
83 | case CONVERT (A52_2F2R, A52_2F1R): | ||
84 | case CONVERT (A52_3F2R, A52_3F1R): | ||
85 | level_3db: | ||
86 | adjust = LEVEL (LEVEL_3DB); | ||
87 | break; | ||
88 | |||
89 | case CONVERT (A52_3F2R, A52_2F1R): | ||
90 | if (clev < LEVEL (LEVEL_PLUS3DB - 1)) | ||
91 | goto level_3db; | ||
92 | /* break thru */ | ||
93 | case CONVERT (A52_3F, A52_STEREO): | ||
94 | case CONVERT (A52_3F1R, A52_2F1R): | ||
95 | case CONVERT (A52_3F1R, A52_2F2R): | ||
96 | case CONVERT (A52_3F2R, A52_2F2R): | ||
97 | adjust = DIV (1, LEVEL (1) + clev); | ||
98 | break; | ||
99 | |||
100 | case CONVERT (A52_2F1R, A52_MONO): | ||
101 | adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev); | ||
102 | break; | ||
103 | |||
104 | case CONVERT (A52_2F1R, A52_STEREO): | ||
105 | case CONVERT (A52_3F1R, A52_3F): | ||
106 | adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB)); | ||
107 | break; | ||
108 | |||
109 | case CONVERT (A52_3F1R, A52_MONO): | ||
110 | adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5)); | ||
111 | break; | ||
112 | |||
113 | case CONVERT (A52_3F1R, A52_STEREO): | ||
114 | adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB)); | ||
115 | break; | ||
116 | |||
117 | case CONVERT (A52_2F2R, A52_MONO): | ||
118 | adjust = DIV (LEVEL_3DB, LEVEL (1) + slev); | ||
119 | break; | ||
120 | |||
121 | case CONVERT (A52_2F2R, A52_STEREO): | ||
122 | case CONVERT (A52_3F2R, A52_3F): | ||
123 | adjust = DIV (1, LEVEL (1) + slev); | ||
124 | break; | ||
125 | |||
126 | case CONVERT (A52_3F2R, A52_MONO): | ||
127 | adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev); | ||
128 | break; | ||
129 | |||
130 | case CONVERT (A52_3F2R, A52_STEREO): | ||
131 | adjust = DIV (1, LEVEL (1) + clev + slev); | ||
132 | break; | ||
133 | |||
134 | case CONVERT (A52_MONO, A52_DOLBY): | ||
135 | adjust = LEVEL (LEVEL_PLUS3DB); | ||
136 | break; | ||
137 | |||
138 | case CONVERT (A52_3F, A52_DOLBY): | ||
139 | case CONVERT (A52_2F1R, A52_DOLBY): | ||
140 | adjust = LEVEL (1 / (1 + LEVEL_3DB)); | ||
141 | break; | ||
142 | |||
143 | case CONVERT (A52_3F1R, A52_DOLBY): | ||
144 | case CONVERT (A52_2F2R, A52_DOLBY): | ||
145 | adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB)); | ||
146 | break; | ||
147 | |||
148 | case CONVERT (A52_3F2R, A52_DOLBY): | ||
149 | adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB)); | ||
150 | break; | ||
151 | |||
152 | default: | ||
153 | return output; | ||
154 | } | ||
155 | |||
156 | *level = MUL_L (*level, adjust); | ||
157 | } | ||
158 | |||
159 | return output; | ||
160 | } | ||
161 | |||
162 | int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level, | ||
163 | level_t clev, level_t slev) | ||
164 | { | ||
165 | level_t level_3db; | ||
166 | |||
167 | level_3db = MUL_C (level, LEVEL_3DB); | ||
168 | |||
169 | switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) { | ||
170 | |||
171 | case CONVERT (A52_CHANNEL, A52_CHANNEL): | ||
172 | case CONVERT (A52_MONO, A52_MONO): | ||
173 | case CONVERT (A52_STEREO, A52_STEREO): | ||
174 | case CONVERT (A52_3F, A52_3F): | ||
175 | case CONVERT (A52_2F1R, A52_2F1R): | ||
176 | case CONVERT (A52_3F1R, A52_3F1R): | ||
177 | case CONVERT (A52_2F2R, A52_2F2R): | ||
178 | case CONVERT (A52_3F2R, A52_3F2R): | ||
179 | case CONVERT (A52_STEREO, A52_DOLBY): | ||
180 | coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level; | ||
181 | return 0; | ||
182 | |||
183 | case CONVERT (A52_CHANNEL, A52_MONO): | ||
184 | coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB); | ||
185 | return 3; | ||
186 | |||
187 | case CONVERT (A52_STEREO, A52_MONO): | ||
188 | coeff[0] = coeff[1] = level_3db; | ||
189 | return 3; | ||
190 | |||
191 | case CONVERT (A52_3F, A52_MONO): | ||
192 | coeff[0] = coeff[2] = level_3db; | ||
193 | coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB); | ||
194 | return 7; | ||
195 | |||
196 | case CONVERT (A52_2F1R, A52_MONO): | ||
197 | coeff[0] = coeff[1] = level_3db; | ||
198 | coeff[2] = MUL_L (level_3db, slev); | ||
199 | return 7; | ||
200 | |||
201 | case CONVERT (A52_2F2R, A52_MONO): | ||
202 | coeff[0] = coeff[1] = level_3db; | ||
203 | coeff[2] = coeff[3] = MUL_L (level_3db, slev); | ||
204 | return 15; | ||
205 | |||
206 | case CONVERT (A52_3F1R, A52_MONO): | ||
207 | coeff[0] = coeff[2] = level_3db; | ||
208 | coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB); | ||
209 | coeff[3] = MUL_L (level_3db, slev); | ||
210 | return 15; | ||
211 | |||
212 | case CONVERT (A52_3F2R, A52_MONO): | ||
213 | coeff[0] = coeff[2] = level_3db; | ||
214 | coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB); | ||
215 | coeff[3] = coeff[4] = MUL_L (level_3db, slev); | ||
216 | return 31; | ||
217 | |||
218 | case CONVERT (A52_MONO, A52_DOLBY): | ||
219 | coeff[0] = level_3db; | ||
220 | return 0; | ||
221 | |||
222 | case CONVERT (A52_3F, A52_DOLBY): | ||
223 | coeff[0] = coeff[2] = coeff[3] = coeff[4] = level; | ||
224 | coeff[1] = level_3db; | ||
225 | return 7; | ||
226 | |||
227 | case CONVERT (A52_3F, A52_STEREO): | ||
228 | case CONVERT (A52_3F1R, A52_2F1R): | ||
229 | case CONVERT (A52_3F2R, A52_2F2R): | ||
230 | coeff[0] = coeff[2] = coeff[3] = coeff[4] = level; | ||
231 | coeff[1] = MUL_L (level, clev); | ||
232 | return 7; | ||
233 | |||
234 | case CONVERT (A52_2F1R, A52_DOLBY): | ||
235 | coeff[0] = coeff[1] = level; | ||
236 | coeff[2] = level_3db; | ||
237 | return 7; | ||
238 | |||
239 | case CONVERT (A52_2F1R, A52_STEREO): | ||
240 | coeff[0] = coeff[1] = level; | ||
241 | coeff[2] = MUL_L (level_3db, slev); | ||
242 | return 7; | ||
243 | |||
244 | case CONVERT (A52_3F1R, A52_DOLBY): | ||
245 | coeff[0] = coeff[2] = level; | ||
246 | coeff[1] = coeff[3] = level_3db; | ||
247 | return 15; | ||
248 | |||
249 | case CONVERT (A52_3F1R, A52_STEREO): | ||
250 | coeff[0] = coeff[2] = level; | ||
251 | coeff[1] = MUL_L (level, clev); | ||
252 | coeff[3] = MUL_L (level_3db, slev); | ||
253 | return 15; | ||
254 | |||
255 | case CONVERT (A52_2F2R, A52_DOLBY): | ||
256 | coeff[0] = coeff[1] = level; | ||
257 | coeff[2] = coeff[3] = level_3db; | ||
258 | return 15; | ||
259 | |||
260 | case CONVERT (A52_2F2R, A52_STEREO): | ||
261 | coeff[0] = coeff[1] = level; | ||
262 | coeff[2] = coeff[3] = MUL_L (level, slev); | ||
263 | return 15; | ||
264 | |||
265 | case CONVERT (A52_3F2R, A52_DOLBY): | ||
266 | coeff[0] = coeff[2] = level; | ||
267 | coeff[1] = coeff[3] = coeff[4] = level_3db; | ||
268 | return 31; | ||
269 | |||
270 | case CONVERT (A52_3F2R, A52_2F1R): | ||
271 | coeff[0] = coeff[2] = level; | ||
272 | coeff[1] = MUL_L (level, clev); | ||
273 | coeff[3] = coeff[4] = level_3db; | ||
274 | return 31; | ||
275 | |||
276 | case CONVERT (A52_3F2R, A52_STEREO): | ||
277 | coeff[0] = coeff[2] = level; | ||
278 | coeff[1] = MUL_L (level, clev); | ||
279 | coeff[3] = coeff[4] = MUL_L (level, slev); | ||
280 | return 31; | ||
281 | |||
282 | case CONVERT (A52_3F1R, A52_3F): | ||
283 | coeff[0] = coeff[1] = coeff[2] = level; | ||
284 | coeff[3] = MUL_L (level_3db, slev); | ||
285 | return 13; | ||
286 | |||
287 | case CONVERT (A52_3F2R, A52_3F): | ||
288 | coeff[0] = coeff[1] = coeff[2] = level; | ||
289 | coeff[3] = coeff[4] = MUL_L (level, slev); | ||
290 | return 29; | ||
291 | |||
292 | case CONVERT (A52_2F2R, A52_2F1R): | ||
293 | coeff[0] = coeff[1] = level; | ||
294 | coeff[2] = coeff[3] = level_3db; | ||
295 | return 12; | ||
296 | |||
297 | case CONVERT (A52_3F2R, A52_3F1R): | ||
298 | coeff[0] = coeff[1] = coeff[2] = level; | ||
299 | coeff[3] = coeff[4] = level_3db; | ||
300 | return 24; | ||
301 | |||
302 | case CONVERT (A52_2F1R, A52_2F2R): | ||
303 | coeff[0] = coeff[1] = level; | ||
304 | coeff[2] = level_3db; | ||
305 | return 0; | ||
306 | |||
307 | case CONVERT (A52_3F1R, A52_2F2R): | ||
308 | coeff[0] = coeff[2] = level; | ||
309 | coeff[1] = MUL_L (level, clev); | ||
310 | coeff[3] = level_3db; | ||
311 | return 7; | ||
312 | |||
313 | case CONVERT (A52_3F1R, A52_3F2R): | ||
314 | coeff[0] = coeff[1] = coeff[2] = level; | ||
315 | coeff[3] = level_3db; | ||
316 | return 0; | ||
317 | |||
318 | case CONVERT (A52_CHANNEL, A52_CHANNEL1): | ||
319 | coeff[0] = level; | ||
320 | coeff[1] = 0; | ||
321 | return 0; | ||
322 | |||
323 | case CONVERT (A52_CHANNEL, A52_CHANNEL2): | ||
324 | coeff[0] = 0; | ||
325 | coeff[1] = level; | ||
326 | return 0; | ||
327 | } | ||
328 | |||
329 | return -1; /* NOTREACHED */ | ||
330 | } | ||
331 | |||
332 | static void mix2to1 (sample_t * dest, sample_t * src) | ||
333 | { | ||
334 | int i; | ||
335 | |||
336 | for (i = 0; i < 256; i++) | ||
337 | dest[i] += BIAS (src[i]); | ||
338 | } | ||
339 | |||
340 | static void mix3to1 (sample_t * samples) | ||
341 | { | ||
342 | int i; | ||
343 | |||
344 | for (i = 0; i < 256; i++) | ||
345 | samples[i] += BIAS (samples[i + 256] + samples[i + 512]); | ||
346 | } | ||
347 | |||
348 | static void mix4to1 (sample_t * samples) | ||
349 | { | ||
350 | int i; | ||
351 | |||
352 | for (i = 0; i < 256; i++) | ||
353 | samples[i] += BIAS (samples[i + 256] + samples[i + 512] + | ||
354 | samples[i + 768]); | ||
355 | } | ||
356 | |||
357 | static void mix5to1 (sample_t * samples) | ||
358 | { | ||
359 | int i; | ||
360 | |||
361 | for (i = 0; i < 256; i++) | ||
362 | samples[i] += BIAS (samples[i + 256] + samples[i + 512] + | ||
363 | samples[i + 768] + samples[i + 1024]); | ||
364 | } | ||
365 | |||
366 | static void mix3to2 (sample_t * samples) | ||
367 | { | ||
368 | int i; | ||
369 | sample_t common; | ||
370 | |||
371 | for (i = 0; i < 256; i++) { | ||
372 | common = BIAS (samples[i + 256]); | ||
373 | samples[i] += common; | ||
374 | samples[i + 256] = samples[i + 512] + common; | ||
375 | } | ||
376 | } | ||
377 | |||
378 | static void mix21to2 (sample_t * left, sample_t * right) | ||
379 | { | ||
380 | int i; | ||
381 | sample_t common; | ||
382 | |||
383 | for (i = 0; i < 256; i++) { | ||
384 | common = BIAS (right[i + 256]); | ||
385 | left[i] += common; | ||
386 | right[i] += common; | ||
387 | } | ||
388 | } | ||
389 | |||
390 | static void mix21toS (sample_t * samples) | ||
391 | { | ||
392 | int i; | ||
393 | sample_t surround; | ||
394 | |||
395 | for (i = 0; i < 256; i++) { | ||
396 | surround = samples[i + 512]; | ||
397 | samples[i] += BIAS (-surround); | ||
398 | samples[i + 256] += BIAS (surround); | ||
399 | } | ||
400 | } | ||
401 | |||
402 | static void mix31to2 (sample_t * samples) | ||
403 | { | ||
404 | int i; | ||
405 | sample_t common; | ||
406 | |||
407 | for (i = 0; i < 256; i++) { | ||
408 | common = BIAS (samples[i + 256] + samples[i + 768]); | ||
409 | samples[i] += common; | ||
410 | samples[i + 256] = samples[i + 512] + common; | ||
411 | } | ||
412 | } | ||
413 | |||
414 | static void mix31toS (sample_t * samples) | ||
415 | { | ||
416 | int i; | ||
417 | sample_t common, surround; | ||
418 | |||
419 | for (i = 0; i < 256; i++) { | ||
420 | common = BIAS (samples[i + 256]); | ||
421 | surround = samples[i + 768]; | ||
422 | samples[i] += common - surround; | ||
423 | samples[i + 256] = samples[i + 512] + common + surround; | ||
424 | } | ||
425 | } | ||
426 | |||
427 | static void mix22toS (sample_t * samples) | ||
428 | { | ||
429 | int i; | ||
430 | sample_t surround; | ||
431 | |||
432 | for (i = 0; i < 256; i++) { | ||
433 | surround = samples[i + 512] + samples[i + 768]; | ||
434 | samples[i] += BIAS (-surround); | ||
435 | samples[i + 256] += BIAS (surround); | ||
436 | } | ||
437 | } | ||
438 | |||
439 | static void mix32to2 (sample_t * samples) | ||
440 | { | ||
441 | int i; | ||
442 | sample_t common; | ||
443 | |||
444 | for (i = 0; i < 256; i++) { | ||
445 | common = BIAS (samples[i + 256]); | ||
446 | samples[i] += common + samples[i + 768]; | ||
447 | samples[i + 256] = common + samples[i + 512] + samples[i + 1024]; | ||
448 | } | ||
449 | } | ||
450 | |||
451 | static void mix32toS (sample_t * samples) | ||
452 | { | ||
453 | int i; | ||
454 | sample_t common, surround; | ||
455 | |||
456 | for (i = 0; i < 256; i++) { | ||
457 | common = BIAS (samples[i + 256]); | ||
458 | surround = samples[i + 768] + samples[i + 1024]; | ||
459 | samples[i] += common - surround; | ||
460 | samples[i + 256] = samples[i + 512] + common + surround; | ||
461 | } | ||
462 | } | ||
463 | |||
464 | static void move2to1 (sample_t * src, sample_t * dest) | ||
465 | { | ||
466 | int i; | ||
467 | |||
468 | for (i = 0; i < 256; i++) | ||
469 | dest[i] = BIAS (src[i] + src[i + 256]); | ||
470 | } | ||
471 | |||
472 | static void zero (sample_t * samples) | ||
473 | { | ||
474 | int i; | ||
475 | |||
476 | for (i = 0; i < 256; i++) | ||
477 | samples[i] = 0; | ||
478 | } | ||
479 | |||
480 | void a52_downmix (sample_t * samples, int acmod, int output, | ||
481 | level_t clev, level_t slev) | ||
482 | { | ||
483 | /* avoid compiler warning */ | ||
484 | (void)clev; | ||
485 | |||
486 | switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) { | ||
487 | |||
488 | case CONVERT (A52_CHANNEL, A52_CHANNEL2): | ||
489 | memcpy (samples, samples + 256, 256 * sizeof (sample_t)); | ||
490 | break; | ||
491 | |||
492 | case CONVERT (A52_CHANNEL, A52_MONO): | ||
493 | case CONVERT (A52_STEREO, A52_MONO): | ||
494 | mix_2to1: | ||
495 | mix2to1 (samples, samples + 256); | ||
496 | break; | ||
497 | |||
498 | case CONVERT (A52_2F1R, A52_MONO): | ||
499 | if (slev == 0) | ||
500 | goto mix_2to1; | ||
501 | case CONVERT (A52_3F, A52_MONO): | ||
502 | mix_3to1: | ||
503 | mix3to1 (samples); | ||
504 | break; | ||
505 | |||
506 | case CONVERT (A52_3F1R, A52_MONO): | ||
507 | if (slev == 0) | ||
508 | goto mix_3to1; | ||
509 | case CONVERT (A52_2F2R, A52_MONO): | ||
510 | if (slev == 0) | ||
511 | goto mix_2to1; | ||
512 | mix4to1 (samples); | ||
513 | break; | ||
514 | |||
515 | case CONVERT (A52_3F2R, A52_MONO): | ||
516 | if (slev == 0) | ||
517 | goto mix_3to1; | ||
518 | mix5to1 (samples); | ||
519 | break; | ||
520 | |||
521 | case CONVERT (A52_MONO, A52_DOLBY): | ||
522 | memcpy (samples + 256, samples, 256 * sizeof (sample_t)); | ||
523 | break; | ||
524 | |||
525 | case CONVERT (A52_3F, A52_STEREO): | ||
526 | case CONVERT (A52_3F, A52_DOLBY): | ||
527 | mix_3to2: | ||
528 | mix3to2 (samples); | ||
529 | break; | ||
530 | |||
531 | case CONVERT (A52_2F1R, A52_STEREO): | ||
532 | if (slev == 0) | ||
533 | break; | ||
534 | mix21to2 (samples, samples + 256); | ||
535 | break; | ||
536 | |||
537 | case CONVERT (A52_2F1R, A52_DOLBY): | ||
538 | mix21toS (samples); | ||
539 | break; | ||
540 | |||
541 | case CONVERT (A52_3F1R, A52_STEREO): | ||
542 | if (slev == 0) | ||
543 | goto mix_3to2; | ||
544 | mix31to2 (samples); | ||
545 | break; | ||
546 | |||
547 | case CONVERT (A52_3F1R, A52_DOLBY): | ||
548 | mix31toS (samples); | ||
549 | break; | ||
550 | |||
551 | case CONVERT (A52_2F2R, A52_STEREO): | ||
552 | if (slev == 0) | ||
553 | break; | ||
554 | mix2to1 (samples, samples + 512); | ||
555 | mix2to1 (samples + 256, samples + 768); | ||
556 | break; | ||
557 | |||
558 | case CONVERT (A52_2F2R, A52_DOLBY): | ||
559 | mix22toS (samples); | ||
560 | break; | ||
561 | |||
562 | case CONVERT (A52_3F2R, A52_STEREO): | ||
563 | if (slev == 0) | ||
564 | goto mix_3to2; | ||
565 | mix32to2 (samples); | ||
566 | break; | ||
567 | |||
568 | case CONVERT (A52_3F2R, A52_DOLBY): | ||
569 | mix32toS (samples); | ||
570 | break; | ||
571 | |||
572 | case CONVERT (A52_3F1R, A52_3F): | ||
573 | if (slev == 0) | ||
574 | break; | ||
575 | mix21to2 (samples, samples + 512); | ||
576 | break; | ||
577 | |||
578 | case CONVERT (A52_3F2R, A52_3F): | ||
579 | if (slev == 0) | ||
580 | break; | ||
581 | mix2to1 (samples, samples + 768); | ||
582 | mix2to1 (samples + 512, samples + 1024); | ||
583 | break; | ||
584 | |||
585 | case CONVERT (A52_3F1R, A52_2F1R): | ||
586 | mix3to2 (samples); | ||
587 | memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t)); | ||
588 | break; | ||
589 | |||
590 | case CONVERT (A52_2F2R, A52_2F1R): | ||
591 | mix2to1 (samples + 512, samples + 768); | ||
592 | break; | ||
593 | |||
594 | case CONVERT (A52_3F2R, A52_2F1R): | ||
595 | mix3to2 (samples); | ||
596 | move2to1 (samples + 768, samples + 512); | ||
597 | break; | ||
598 | |||
599 | case CONVERT (A52_3F2R, A52_3F1R): | ||
600 | mix2to1 (samples + 768, samples + 1024); | ||
601 | break; | ||
602 | |||
603 | case CONVERT (A52_2F1R, A52_2F2R): | ||
604 | memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t)); | ||
605 | break; | ||
606 | |||
607 | case CONVERT (A52_3F1R, A52_2F2R): | ||
608 | mix3to2 (samples); | ||
609 | memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t)); | ||
610 | break; | ||
611 | |||
612 | case CONVERT (A52_3F2R, A52_2F2R): | ||
613 | mix3to2 (samples); | ||
614 | memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t)); | ||
615 | memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t)); | ||
616 | break; | ||
617 | |||
618 | case CONVERT (A52_3F1R, A52_3F2R): | ||
619 | memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t)); | ||
620 | break; | ||
621 | } | ||
622 | } | ||
623 | |||
624 | void a52_upmix (sample_t * samples, int acmod, int output) | ||
625 | { | ||
626 | switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) { | ||
627 | |||
628 | case CONVERT (A52_CHANNEL, A52_CHANNEL2): | ||
629 | memcpy (samples + 256, samples, 256 * sizeof (sample_t)); | ||
630 | break; | ||
631 | |||
632 | case CONVERT (A52_3F2R, A52_MONO): | ||
633 | zero (samples + 1024); | ||
634 | case CONVERT (A52_3F1R, A52_MONO): | ||
635 | case CONVERT (A52_2F2R, A52_MONO): | ||
636 | zero (samples + 768); | ||
637 | case CONVERT (A52_3F, A52_MONO): | ||
638 | case CONVERT (A52_2F1R, A52_MONO): | ||
639 | zero (samples + 512); | ||
640 | case CONVERT (A52_CHANNEL, A52_MONO): | ||
641 | case CONVERT (A52_STEREO, A52_MONO): | ||
642 | zero (samples + 256); | ||
643 | break; | ||
644 | |||
645 | case CONVERT (A52_3F2R, A52_STEREO): | ||
646 | case CONVERT (A52_3F2R, A52_DOLBY): | ||
647 | zero (samples + 1024); | ||
648 | case CONVERT (A52_3F1R, A52_STEREO): | ||
649 | case CONVERT (A52_3F1R, A52_DOLBY): | ||
650 | zero (samples + 768); | ||
651 | case CONVERT (A52_3F, A52_STEREO): | ||
652 | case CONVERT (A52_3F, A52_DOLBY): | ||
653 | mix_3to2: | ||
654 | memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t)); | ||
655 | zero (samples + 256); | ||
656 | break; | ||
657 | |||
658 | case CONVERT (A52_2F2R, A52_STEREO): | ||
659 | case CONVERT (A52_2F2R, A52_DOLBY): | ||
660 | zero (samples + 768); | ||
661 | case CONVERT (A52_2F1R, A52_STEREO): | ||
662 | case CONVERT (A52_2F1R, A52_DOLBY): | ||
663 | zero (samples + 512); | ||
664 | break; | ||
665 | |||
666 | case CONVERT (A52_3F2R, A52_3F): | ||
667 | zero (samples + 1024); | ||
668 | case CONVERT (A52_3F1R, A52_3F): | ||
669 | case CONVERT (A52_2F2R, A52_2F1R): | ||
670 | zero (samples + 768); | ||
671 | break; | ||
672 | |||
673 | case CONVERT (A52_3F2R, A52_3F1R): | ||
674 | zero (samples + 1024); | ||
675 | break; | ||
676 | |||
677 | case CONVERT (A52_3F2R, A52_2F1R): | ||
678 | zero (samples + 1024); | ||
679 | case CONVERT (A52_3F1R, A52_2F1R): | ||
680 | mix_31to21: | ||
681 | memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t)); | ||
682 | goto mix_3to2; | ||
683 | |||
684 | case CONVERT (A52_3F2R, A52_2F2R): | ||
685 | memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t)); | ||
686 | goto mix_31to21; | ||
687 | } | ||
688 | } | ||