Mercurial > mplayer.hg

comparison liba52/downmix.c @ 3394:35b18ed357c2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
imported from liba52 CVS
author arpi
date Sun, 09 Dec 2001 15:28:44 +0000
parents
children 0e4ff1cac6a2
comparison
equal deleted inserted replaced
3393:3624cd351618 3394:35b18ed357c2
1 /*
2 * downmix.c
3 * Copyright (C) 2000-2001 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.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 downmix_init (int input, int flags, sample_t * level,
35 sample_t clev, sample_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_3DB))))
71 output = A52_DOLBY;
72
73 if (flags & A52_ADJUST_LEVEL)
74 switch (CONVERT (input & 7, output)) {
75
76 case CONVERT (A52_3F, A52_MONO):
77 *level *= LEVEL_3DB / (1 + clev);
78 break;
79
80 case CONVERT (A52_STEREO, A52_MONO):
81 case CONVERT (A52_2F2R, A52_2F1R):
82 case CONVERT (A52_3F2R, A52_3F1R):
83 level_3db:
84 *level *= LEVEL_3DB;
85 break;
86
87 case CONVERT (A52_3F2R, A52_2F1R):
88 if (clev < LEVEL_PLUS3DB - 1)
89 goto level_3db;
90 /* break thru */
91 case CONVERT (A52_3F, A52_STEREO):
92 case CONVERT (A52_3F1R, A52_2F1R):
93 case CONVERT (A52_3F1R, A52_2F2R):
94 case CONVERT (A52_3F2R, A52_2F2R):
95 *level /= 1 + clev;
96 break;
97
98 case CONVERT (A52_2F1R, A52_MONO):
99 *level *= LEVEL_PLUS3DB / (2 + slev);
100 break;
101
102 case CONVERT (A52_2F1R, A52_STEREO):
103 case CONVERT (A52_3F1R, A52_3F):
104 *level /= 1 + slev * LEVEL_3DB;
105 break;
106
107 case CONVERT (A52_3F1R, A52_MONO):
108 *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
109 break;
110
111 case CONVERT (A52_3F1R, A52_STEREO):
112 *level /= 1 + clev + slev * LEVEL_3DB;
113 break;
114
115 case CONVERT (A52_2F2R, A52_MONO):
116 *level *= LEVEL_3DB / (1 + slev);
117 break;
118
119 case CONVERT (A52_2F2R, A52_STEREO):
120 case CONVERT (A52_3F2R, A52_3F):
121 *level /= 1 + slev;
122 break;
123
124 case CONVERT (A52_3F2R, A52_MONO):
125 *level *= LEVEL_3DB / (1 + clev + slev);
126 break;
127
128 case CONVERT (A52_3F2R, A52_STEREO):
129 *level /= 1 + clev + slev;
130 break;
131
132 case CONVERT (A52_MONO, A52_DOLBY):
133 *level *= LEVEL_PLUS3DB;
134 break;
135
136 case CONVERT (A52_3F, A52_DOLBY):
137 case CONVERT (A52_2F1R, A52_DOLBY):
138 *level *= 1 / (1 + LEVEL_3DB);
139 break;
140
141 case CONVERT (A52_3F1R, A52_DOLBY):
142 case CONVERT (A52_2F2R, A52_DOLBY):
143 *level *= 1 / (1 + 2 * LEVEL_3DB);
144 break;
145
146 case CONVERT (A52_3F2R, A52_DOLBY):
147 *level *= 1 / (1 + 3 * LEVEL_3DB);
148 break;
149 }
150
151 return output;
152 }
153
154 int downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level,
155 sample_t clev, sample_t slev)
156 {
157 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
158
159 case CONVERT (A52_CHANNEL, A52_CHANNEL):
160 case CONVERT (A52_MONO, A52_MONO):
161 case CONVERT (A52_STEREO, A52_STEREO):
162 case CONVERT (A52_3F, A52_3F):
163 case CONVERT (A52_2F1R, A52_2F1R):
164 case CONVERT (A52_3F1R, A52_3F1R):
165 case CONVERT (A52_2F2R, A52_2F2R):
166 case CONVERT (A52_3F2R, A52_3F2R):
167 case CONVERT (A52_STEREO, A52_DOLBY):
168 coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
169 return 0;
170
171 case CONVERT (A52_CHANNEL, A52_MONO):
172 coeff[0] = coeff[1] = level * LEVEL_6DB;
173 return 3;
174
175 case CONVERT (A52_STEREO, A52_MONO):
176 coeff[0] = coeff[1] = level * LEVEL_3DB;
177 return 3;
178
179 case CONVERT (A52_3F, A52_MONO):
180 coeff[0] = coeff[2] = level * LEVEL_3DB;
181 coeff[1] = level * clev * LEVEL_PLUS3DB;
182 return 7;
183
184 case CONVERT (A52_2F1R, A52_MONO):
185 coeff[0] = coeff[1] = level * LEVEL_3DB;
186 coeff[2] = level * slev * LEVEL_3DB;
187 return 7;
188
189 case CONVERT (A52_2F2R, A52_MONO):
190 coeff[0] = coeff[1] = level * LEVEL_3DB;
191 coeff[2] = coeff[3] = level * slev * LEVEL_3DB;
192 return 15;
193
194 case CONVERT (A52_3F1R, A52_MONO):
195 coeff[0] = coeff[2] = level * LEVEL_3DB;
196 coeff[1] = level * clev * LEVEL_PLUS3DB;
197 coeff[3] = level * slev * LEVEL_3DB;
198 return 15;
199
200 case CONVERT (A52_3F2R, A52_MONO):
201 coeff[0] = coeff[2] = level * LEVEL_3DB;
202 coeff[1] = level * clev * LEVEL_PLUS3DB;
203 coeff[3] = coeff[4] = level * slev * LEVEL_3DB;
204 return 31;
205
206 case CONVERT (A52_MONO, A52_DOLBY):
207 coeff[0] = level * LEVEL_3DB;
208 return 0;
209
210 case CONVERT (A52_3F, A52_DOLBY):
211 clev = LEVEL_3DB;
212 case CONVERT (A52_3F, A52_STEREO):
213 case CONVERT (A52_3F1R, A52_2F1R):
214 case CONVERT (A52_3F2R, A52_2F2R):
215 coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
216 coeff[1] = level * clev;
217 return 7;
218
219 case CONVERT (A52_2F1R, A52_DOLBY):
220 slev = 1;
221 case CONVERT (A52_2F1R, A52_STEREO):
222 coeff[0] = coeff[1] = level;
223 coeff[2] = level * slev * LEVEL_3DB;
224 return 7;
225
226 case CONVERT (A52_3F1R, A52_DOLBY):
227 clev = LEVEL_3DB;
228 slev = 1;
229 case CONVERT (A52_3F1R, A52_STEREO):
230 coeff[0] = coeff[2] = level;
231 coeff[1] = level * clev;
232 coeff[3] = level * slev * LEVEL_3DB;
233 return 15;
234
235 case CONVERT (A52_2F2R, A52_DOLBY):
236 slev = LEVEL_3DB;
237 case CONVERT (A52_2F2R, A52_STEREO):
238 coeff[0] = coeff[1] = level;
239 coeff[2] = coeff[3] = level * slev;
240 return 15;
241
242 case CONVERT (A52_3F2R, A52_DOLBY):
243 clev = LEVEL_3DB;
244 case CONVERT (A52_3F2R, A52_2F1R):
245 slev = LEVEL_3DB;
246 case CONVERT (A52_3F2R, A52_STEREO):
247 coeff[0] = coeff[2] = level;
248 coeff[1] = level * clev;
249 coeff[3] = coeff[4] = level * slev;
250 return 31;
251
252 case CONVERT (A52_3F1R, A52_3F):
253 coeff[0] = coeff[1] = coeff[2] = level;
254 coeff[3] = level * slev * LEVEL_3DB;
255 return 13;
256
257 case CONVERT (A52_3F2R, A52_3F):
258 coeff[0] = coeff[1] = coeff[2] = level;
259 coeff[3] = coeff[4] = level * slev;
260 return 29;
261
262 case CONVERT (A52_2F2R, A52_2F1R):
263 coeff[0] = coeff[1] = level;
264 coeff[2] = coeff[3] = level * LEVEL_3DB;
265 return 12;
266
267 case CONVERT (A52_3F2R, A52_3F1R):
268 coeff[0] = coeff[1] = coeff[2] = level;
269 coeff[3] = coeff[4] = level * LEVEL_3DB;
270 return 24;
271
272 case CONVERT (A52_2F1R, A52_2F2R):
273 coeff[0] = coeff[1] = level;
274 coeff[2] = level * LEVEL_3DB;
275 return 0;
276
277 case CONVERT (A52_3F1R, A52_2F2R):
278 coeff[0] = coeff[2] = level;
279 coeff[1] = level * clev;
280 coeff[3] = level * LEVEL_3DB;
281 return 7;
282
283 case CONVERT (A52_3F1R, A52_3F2R):
284 coeff[0] = coeff[1] = coeff[2] = level;
285 coeff[3] = level * LEVEL_3DB;
286 return 0;
287
288 case CONVERT (A52_CHANNEL, A52_CHANNEL1):
289 coeff[0] = level;
290 coeff[1] = 0;
291 return 0;
292
293 case CONVERT (A52_CHANNEL, A52_CHANNEL2):
294 coeff[0] = 0;
295 coeff[1] = level;
296 return 0;
297 }
298
299 return -1; /* NOTREACHED */
300 }
301
302 static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
303 {
304 int i;
305
306 for (i = 0; i < 256; i++)
307 dest[i] += src[i] + bias;
308 }
309
310 static void mix3to1 (sample_t * samples, sample_t bias)
311 {
312 int i;
313
314 for (i = 0; i < 256; i++)
315 samples[i] += samples[i + 256] + samples[i + 512] + bias;
316 }
317
318 static void mix4to1 (sample_t * samples, sample_t bias)
319 {
320 int i;
321
322 for (i = 0; i < 256; i++)
323 samples[i] += (samples[i + 256] + samples[i + 512] +
324 samples[i + 768] + bias);
325 }
326
327 static void mix5to1 (sample_t * samples, sample_t bias)
328 {
329 int i;
330
331 for (i = 0; i < 256; i++)
332 samples[i] += (samples[i + 256] + samples[i + 512] +
333 samples[i + 768] + samples[i + 1024] + bias);
334 }
335
336 static void mix3to2 (sample_t * samples, sample_t bias)
337 {
338 int i;
339 sample_t common;
340
341 for (i = 0; i < 256; i++) {
342 common = samples[i + 256] + bias;
343 samples[i] += common;
344 samples[i + 256] = samples[i + 512] + common;
345 }
346 }
347
348 static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
349 {
350 int i;
351 sample_t common;
352
353 for (i = 0; i < 256; i++) {
354 common = right[i + 256] + bias;
355 left[i] += common;
356 right[i] += common;
357 }
358 }
359
360 static void mix21toS (sample_t * samples, sample_t bias)
361 {
362 int i;
363 sample_t surround;
364
365 for (i = 0; i < 256; i++) {
366 surround = samples[i + 512];
367 samples[i] += bias - surround;
368 samples[i + 256] += bias + surround;
369 }
370 }
371
372 static void mix31to2 (sample_t * samples, sample_t bias)
373 {
374 int i;
375 sample_t common;
376
377 for (i = 0; i < 256; i++) {
378 common = samples[i + 256] + samples[i + 768] + bias;
379 samples[i] += common;
380 samples[i + 256] = samples[i + 512] + common;
381 }
382 }
383
384 static void mix31toS (sample_t * samples, sample_t bias)
385 {
386 int i;
387 sample_t common, surround;
388
389 for (i = 0; i < 256; i++) {
390 common = samples[i + 256] + bias;
391 surround = samples[i + 768];
392 samples[i] += common - surround;
393 samples[i + 256] = samples[i + 512] + common + surround;
394 }
395 }
396
397 static void mix22toS (sample_t * samples, sample_t bias)
398 {
399 int i;
400 sample_t surround;
401
402 for (i = 0; i < 256; i++) {
403 surround = samples[i + 512] + samples[i + 768];
404 samples[i] += bias - surround;
405 samples[i + 256] += bias + surround;
406 }
407 }
408
409 static void mix32to2 (sample_t * samples, sample_t bias)
410 {
411 int i;
412 sample_t common;
413
414 for (i = 0; i < 256; i++) {
415 common = samples[i + 256] + bias;
416 samples[i] += common + samples[i + 768];
417 samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
418 }
419 }
420
421 static void mix32toS (sample_t * samples, sample_t bias)
422 {
423 int i;
424 sample_t common, surround;
425
426 for (i = 0; i < 256; i++) {
427 common = samples[i + 256] + bias;
428 surround = samples[i + 768] + samples[i + 1024];
429 samples[i] += common - surround;
430 samples[i + 256] = samples[i + 512] + common + surround;
431 }
432 }
433
434 static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
435 {
436 int i;
437
438 for (i = 0; i < 256; i++)
439 dest[i] = src[i] + src[i + 256] + bias;
440 }
441
442 static void zero (sample_t * samples)
443 {
444 int i;
445
446 for (i = 0; i < 256; i++)
447 samples[i] = 0;
448 }
449
450 void downmix (sample_t * samples, int acmod, int output, sample_t bias,
451 sample_t clev, sample_t slev)
452 {
453 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
454
455 case CONVERT (A52_CHANNEL, A52_CHANNEL2):
456 memcpy (samples, samples + 256, 256 * sizeof (sample_t));
457 break;
458
459 case CONVERT (A52_CHANNEL, A52_MONO):
460 case CONVERT (A52_STEREO, A52_MONO):
461 mix_2to1:
462 mix2to1 (samples, samples + 256, bias);
463 break;
464
465 case CONVERT (A52_2F1R, A52_MONO):
466 if (slev == 0)
467 goto mix_2to1;
468 case CONVERT (A52_3F, A52_MONO):
469 mix_3to1:
470 mix3to1 (samples, bias);
471 break;
472
473 case CONVERT (A52_3F1R, A52_MONO):
474 if (slev == 0)
475 goto mix_3to1;
476 case CONVERT (A52_2F2R, A52_MONO):
477 if (slev == 0)
478 goto mix_2to1;
479 mix4to1 (samples, bias);
480 break;
481
482 case CONVERT (A52_3F2R, A52_MONO):
483 if (slev == 0)
484 goto mix_3to1;
485 mix5to1 (samples, bias);
486 break;
487
488 case CONVERT (A52_MONO, A52_DOLBY):
489 memcpy (samples + 256, samples, 256 * sizeof (sample_t));
490 break;
491
492 case CONVERT (A52_3F, A52_STEREO):
493 case CONVERT (A52_3F, A52_DOLBY):
494 mix_3to2:
495 mix3to2 (samples, bias);
496 break;
497
498 case CONVERT (A52_2F1R, A52_STEREO):
499 if (slev == 0)
500 break;
501 mix21to2 (samples, samples + 256, bias);
502 break;
503
504 case CONVERT (A52_2F1R, A52_DOLBY):
505 mix21toS (samples, bias);
506 break;
507
508 case CONVERT (A52_3F1R, A52_STEREO):
509 if (slev == 0)
510 goto mix_3to2;
511 mix31to2 (samples, bias);
512 break;
513
514 case CONVERT (A52_3F1R, A52_DOLBY):
515 mix31toS (samples, bias);
516 break;
517
518 case CONVERT (A52_2F2R, A52_STEREO):
519 if (slev == 0)
520 break;
521 mix2to1 (samples, samples + 512, bias);
522 mix2to1 (samples + 256, samples + 768, bias);
523 break;
524
525 case CONVERT (A52_2F2R, A52_DOLBY):
526 mix22toS (samples, bias);
527 break;
528
529 case CONVERT (A52_3F2R, A52_STEREO):
530 if (slev == 0)
531 goto mix_3to2;
532 mix32to2 (samples, bias);
533 break;
534
535 case CONVERT (A52_3F2R, A52_DOLBY):
536 mix32toS (samples, bias);
537 break;
538
539 case CONVERT (A52_3F1R, A52_3F):
540 if (slev == 0)
541 break;
542 mix21to2 (samples, samples + 512, bias);
543 break;
544
545 case CONVERT (A52_3F2R, A52_3F):
546 if (slev == 0)
547 break;
548 mix2to1 (samples, samples + 768, bias);
549 mix2to1 (samples + 512, samples + 1024, bias);
550 break;
551
552 case CONVERT (A52_3F1R, A52_2F1R):
553 mix3to2 (samples, bias);
554 memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
555 break;
556
557 case CONVERT (A52_2F2R, A52_2F1R):
558 mix2to1 (samples + 512, samples + 768, bias);
559 break;
560
561 case CONVERT (A52_3F2R, A52_2F1R):
562 mix3to2 (samples, bias);
563 move2to1 (samples + 768, samples + 512, bias);
564 break;
565
566 case CONVERT (A52_3F2R, A52_3F1R):
567 mix2to1 (samples + 768, samples + 1024, bias);
568 break;
569
570 case CONVERT (A52_2F1R, A52_2F2R):
571 memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
572 break;
573
574 case CONVERT (A52_3F1R, A52_2F2R):
575 mix3to2 (samples, bias);
576 memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
577 break;
578
579 case CONVERT (A52_3F2R, A52_2F2R):
580 mix3to2 (samples, bias);
581 memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
582 memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
583 break;
584
585 case CONVERT (A52_3F1R, A52_3F2R):
586 memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t));
587 break;
588 }
589 }
590
591 void upmix (sample_t * samples, int acmod, int output)
592 {
593 switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
594
595 case CONVERT (A52_CHANNEL, A52_CHANNEL2):
596 memcpy (samples + 256, samples, 256 * sizeof (sample_t));
597 break;
598
599 case CONVERT (A52_3F2R, A52_MONO):
600 zero (samples + 1024);
601 case CONVERT (A52_3F1R, A52_MONO):
602 case CONVERT (A52_2F2R, A52_MONO):
603 zero (samples + 768);
604 case CONVERT (A52_3F, A52_MONO):
605 case CONVERT (A52_2F1R, A52_MONO):
606 zero (samples + 512);
607 case CONVERT (A52_CHANNEL, A52_MONO):
608 case CONVERT (A52_STEREO, A52_MONO):
609 zero (samples + 256);
610 break;
611
612 case CONVERT (A52_3F2R, A52_STEREO):
613 case CONVERT (A52_3F2R, A52_DOLBY):
614 zero (samples + 1024);
615 case CONVERT (A52_3F1R, A52_STEREO):
616 case CONVERT (A52_3F1R, A52_DOLBY):
617 zero (samples + 768);
618 case CONVERT (A52_3F, A52_STEREO):
619 case CONVERT (A52_3F, A52_DOLBY):
620 mix_3to2:
621 memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
622 zero (samples + 256);
623 break;
624
625 case CONVERT (A52_2F2R, A52_STEREO):
626 case CONVERT (A52_2F2R, A52_DOLBY):
627 zero (samples + 768);
628 case CONVERT (A52_2F1R, A52_STEREO):
629 case CONVERT (A52_2F1R, A52_DOLBY):
630 zero (samples + 512);
631 break;
632
633 case CONVERT (A52_3F2R, A52_3F):
634 zero (samples + 1024);
635 case CONVERT (A52_3F1R, A52_3F):
636 case CONVERT (A52_2F2R, A52_2F1R):
637 zero (samples + 768);
638 break;
639
640 case CONVERT (A52_3F2R, A52_3F1R):
641 zero (samples + 1024);
642 break;
643
644 case CONVERT (A52_3F2R, A52_2F1R):
645 zero (samples + 1024);
646 case CONVERT (A52_3F1R, A52_2F1R):
647 mix_31to21:
648 memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
649 goto mix_3to2;
650
651 case CONVERT (A52_3F2R, A52_2F2R):
652 memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
653 goto mix_31to21;
654 }
655 }