* add support for liba52
[ffmpeg.git] / libavcodec / liba52 / downmix.c
1 /*
2  * downmix.c
3  * Copyright (C) 2000-2002 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 a52_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 a52_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 a52_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 a52_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 }