8147182b123e4370735b52b7949409fd54e59d54
[ffmpeg.git] / libavcodec / libac3 / downmix.c
1 /*
2  *
3  *  downmix.c
4  *    
5  *      Copyright (C) Aaron Holtzman - Sept 1999
6  *
7  *      Originally based on code by Yuqing Deng.
8  *
9  *  This file is part of ac3dec, a free Dolby AC-3 stream decoder.
10  *      
11  *  ac3dec is free software; you can redistribute it and/or modify
12  *  it under the terms of the GNU General Public License as published by
13  *  the Free Software Foundation; either version 2, or (at your option)
14  *  any later version.
15  *   
16  *  ac3dec is distributed in the hope that it will be useful,
17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  *  GNU General Public License for more details.
20  *   
21  *  You should have received a copy of the GNU General Public License
22  *  along with GNU Make; see the file COPYING.  If not, write to
23  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
24  *
25  *
26  */
27
28 #include "../common.h"
29 #include <math.h>
30 #include "ac3.h"
31 #include "ac3_internal.h"
32
33
34 #define CONVERT(acmod,output) (((output) << 3) + (acmod))
35
36 int downmix_init (int input, int flags, float * level, float clev, float slev)
37 {
38     static uint8_t table[11][8] = {
39         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_STEREO,
40          AC3_STEREO,   AC3_STEREO, AC3_STEREO, AC3_STEREO},
41         {AC3_MONO,     AC3_MONO,   AC3_MONO,   AC3_MONO,
42          AC3_MONO,     AC3_MONO,   AC3_MONO,   AC3_MONO},
43         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_STEREO,
44          AC3_STEREO,   AC3_STEREO, AC3_STEREO, AC3_STEREO},
45         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_3F,
46          AC3_STEREO,   AC3_3F,     AC3_STEREO, AC3_3F},
47         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_STEREO,
48          AC3_2F1R,     AC3_2F1R,   AC3_2F1R,   AC3_2F1R},
49         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_STEREO,
50          AC3_2F1R,     AC3_3F1R,   AC3_2F1R,   AC3_3F1R},
51         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_3F,
52          AC3_2F2R,     AC3_2F2R,   AC3_2F2R,   AC3_2F2R},
53         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_3F,
54          AC3_2F2R,     AC3_3F2R,   AC3_2F2R,   AC3_3F2R},
55         {AC3_CHANNEL1, AC3_MONO,   AC3_MONO,   AC3_MONO,
56          AC3_MONO,     AC3_MONO,   AC3_MONO,   AC3_MONO},
57         {AC3_CHANNEL2, AC3_MONO,   AC3_MONO,   AC3_MONO,
58          AC3_MONO,     AC3_MONO,   AC3_MONO,   AC3_MONO},
59         {AC3_CHANNEL,  AC3_DOLBY,  AC3_STEREO, AC3_DOLBY,
60          AC3_DOLBY,    AC3_DOLBY,  AC3_DOLBY,  AC3_DOLBY}
61     };
62     int output;
63
64     output = flags & AC3_CHANNEL_MASK;
65     if (output > AC3_DOLBY)
66         return -1;
67
68     output = table[output][input & 7];
69
70     if ((output == AC3_STEREO) &&
71         ((input == AC3_DOLBY) || ((input == AC3_3F) && (clev == LEVEL_3DB))))
72         output = AC3_DOLBY;
73
74     if (flags & AC3_ADJUST_LEVEL)
75         switch (CONVERT (input & 7, output)) {
76
77         case CONVERT (AC3_3F, AC3_MONO):
78             *level *= LEVEL_3DB / (1 + clev);
79             break;
80
81         case CONVERT (AC3_STEREO, AC3_MONO):
82         case CONVERT (AC3_2F2R, AC3_2F1R):
83         case CONVERT (AC3_3F2R, AC3_3F1R):
84         level_3db:
85             *level *= LEVEL_3DB;
86             break;
87
88         case CONVERT (AC3_3F2R, AC3_2F1R):
89             if (clev < LEVEL_PLUS3DB - 1)
90                 goto level_3db;
91             // break thru
92         case CONVERT (AC3_3F, AC3_STEREO):
93         case CONVERT (AC3_3F1R, AC3_2F1R):
94         case CONVERT (AC3_3F1R, AC3_2F2R):
95         case CONVERT (AC3_3F2R, AC3_2F2R):
96             *level /= 1 + clev;
97             break;
98
99         case CONVERT (AC3_2F1R, AC3_MONO):
100             *level *= LEVEL_PLUS3DB / (2 + slev);
101             break;
102
103         case CONVERT (AC3_2F1R, AC3_STEREO):
104         case CONVERT (AC3_3F1R, AC3_3F):
105             *level /= 1 + slev * LEVEL_3DB;
106             break;
107
108         case CONVERT (AC3_3F1R, AC3_MONO):
109             *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
110             break;
111
112         case CONVERT (AC3_3F1R, AC3_STEREO):
113             *level /= 1 + clev + slev * LEVEL_3DB;
114             break;
115
116         case CONVERT (AC3_2F2R, AC3_MONO):
117             *level *= LEVEL_3DB / (1 + slev);
118             break;
119
120         case CONVERT (AC3_2F2R, AC3_STEREO):
121         case CONVERT (AC3_3F2R, AC3_3F):
122             *level /= (1 + slev);
123             break;
124
125         case CONVERT (AC3_3F2R, AC3_MONO):
126             *level *= LEVEL_3DB / (1 + clev + slev);
127             break;
128
129         case CONVERT (AC3_3F2R, AC3_STEREO):
130             *level /= 1 + clev + slev;
131             break;
132
133         case CONVERT (AC3_MONO, AC3_DOLBY):
134             *level *= LEVEL_PLUS3DB;
135             break;
136
137         case CONVERT (AC3_3F, AC3_DOLBY):
138         case CONVERT (AC3_2F1R, AC3_DOLBY):
139             *level *= 1 / (1 + LEVEL_3DB);
140             break;
141
142         case CONVERT (AC3_3F1R, AC3_DOLBY):
143         case CONVERT (AC3_2F2R, AC3_DOLBY):
144             *level *= 1 / (1 + 2 * LEVEL_3DB);
145             break;
146
147         case CONVERT (AC3_3F2R, AC3_DOLBY):
148             *level *= 1 / (1 + 3 * LEVEL_3DB);
149             break;
150     }
151
152     return output;
153 }
154
155 static void mix1to1 (float * samples, float level, float bias)
156 {
157     int i;
158
159     for (i = 0; i < 256; i++)
160         samples[i] = samples[i] * level + bias;
161 }
162
163 static void move1to1 (float * src, float * dest, float level, float bias)
164 {
165     int i;
166
167     for (i = 0; i < 256; i++)
168         dest[i] = src[i] * level + bias;
169 }
170
171 static void mix2to1 (float * samples, float level, float bias)
172 {
173     int i;
174
175     for (i = 0; i < 256; i++)
176         samples[i] = (samples[i] + samples[i + 256]) * level + bias;
177 }
178
179 static void move2to1 (float * src, float * dest, float level, float bias)
180 {
181     int i;
182
183     for (i = 0; i < 256; i++)
184         dest[i] = (src[i] + src[i + 256]) * level + bias;
185 }
186
187 static void mix3to1 (float * samples, float level, float clev, float bias)
188 {
189     int i;
190
191     for (i = 0; i < 256; i++)
192         samples[i] = ((samples[i] + samples[i + 512]) * level +
193                       samples[i + 256] * clev + bias);
194 }
195
196 static void mix21to1 (float * samples, float level, float slev, float bias)
197 {
198     int i;
199
200     for (i = 0; i < 256; i++)
201         samples[i] = ((samples[i] + samples[i + 256]) * level +
202                       samples[i + 512] * slev + bias);
203 }
204
205 static void mix31to1 (float * samples, float level, float clev, float slev,
206                       float bias)
207 {
208     int i;
209
210     for (i = 0; i < 256; i++)
211         samples[i] = ((samples[i] + samples[i + 512]) * level +
212                       samples[i + 256] * clev + samples[i + 768] * slev +
213                       bias);
214 }
215
216 static void mix22to1 (float * samples, float level, float slev, float bias)
217 {
218     int i;
219
220     for (i = 0; i < 256; i++)
221         samples[i] = ((samples[i] + samples[i + 256]) * level +
222                       (samples[i + 512] + samples[i + 768]) * slev + bias);
223 }
224
225 static void mix32to1 (float * samples, float level, float clev, float slev,
226                       float bias)
227 {
228     int i;
229
230     for (i = 0; i < 256; i++)
231         samples[i] = ((samples[i] + samples[i + 512]) * level +
232                       samples[i + 256] * clev +
233                       (samples[i + 768] + samples[i + 1024]) * slev + bias);
234 }
235
236 static void mix1to2 (float * src, float * dest, float level, float bias)
237 {
238     int i;
239
240     for (i = 0; i < 256; i++)
241         dest[i] = src[i] = src[i] * level + bias;
242 }
243
244 static void mix3to2 (float * samples, float level, float clev, float bias)
245 {
246     int i;
247     float common;
248
249     for (i = 0; i < 256; i++) {
250         common = samples[i + 256] * clev + bias;
251         samples[i] = samples[i] * level + common;
252         samples[i + 256] = samples[i + 512] * level + common;
253     }
254 }
255
256 static void mix21to2 (float * left, float * right, float level, float slev,
257                       float bias)
258 {
259     int i;
260     float common;
261
262     for (i = 0; i < 256; i++) {
263         common = right[i + 256] * slev + bias;
264         left[i] = left[i] * level + common;
265         right[i] = right[i] * level + common;
266     }
267 }
268
269 static void mix11to1 (float * front, float * rear, float level, float slev,
270                       float bias)
271 {
272     int i;
273
274     for (i = 0; i < 256; i++)
275         front[i] = front[i] * level + rear[i] * slev + bias;
276 }
277
278 static void mix31to2 (float * samples, float level, float clev, float slev,
279                       float bias)
280 {
281     int i;
282     float common;
283
284     for (i = 0; i < 256; i++) {
285         common = samples[i + 256] * clev + samples[i + 768] * slev + bias;
286         samples[i] = samples[i] * level + common;
287         samples[i + 256] = samples[i + 512] * level + common;
288     }
289 }
290
291 static void mix32to2 (float * samples, float level, float clev, float slev,
292                       float bias)
293 {
294     int i;
295     float common;
296
297     for (i = 0; i < 256; i++) {
298         common = samples[i + 256] * clev + bias;
299         samples[i] = samples[i] * level + common + samples[i + 768] * slev;
300         samples[i + 256] = (samples[i + 512] * level + common +
301                             samples[i + 1024] * slev);
302     }
303 }
304
305 static void mix21toS (float * samples, float level, float level3db, float bias)
306 {
307     int i;
308     float surround;
309
310     for (i = 0; i < 256; i++) {
311         surround = samples[i + 512] * level3db;
312         samples[i] = samples[i] * level - surround + bias;
313         samples[i + 256] = samples[i + 256] * level + surround + bias;
314     }
315 }
316
317 static void mix22toS (float * samples, float level, float level3db, float bias)
318 {
319     int i;
320     float surround;
321
322     for (i = 0; i < 256; i++) {
323         surround = (samples[i + 512] + samples[i + 768]) * level3db;
324         samples[i] = samples[i] * level - surround + bias;
325         samples[i + 256] = samples[i + 256] * level + surround + bias;
326     }
327 }
328
329 static void mix31toS (float * samples, float level, float level3db, float bias)
330 {
331     int i;
332     float common, surround;
333
334     for (i = 0; i < 256; i++) {
335         common = samples[i + 256] * level3db + bias;
336         surround = samples[i + 768] * level3db;
337         samples[i] = samples[i] * level + common - surround;
338         samples[i + 256] = samples[i + 512] * level + common + surround;
339     }
340 }
341
342 static void mix32toS (float * samples, float level, float level3db, float bias)
343 {
344     int i;
345     float common, surround;
346
347     for (i = 0; i < 256; i++) {
348         common = samples[i + 256] * level3db + bias;
349         surround = (samples[i + 768] + samples[i + 1024]) * level3db;
350         samples[i] = samples[i] * level + common - surround;
351         samples[i + 256] = samples[i + 512] * level + common + surround;
352     }
353 }
354
355 void downmix (float * samples, int acmod, int output, float level, float bias,
356               float clev, float slev)
357 {
358     switch (CONVERT (acmod, output & AC3_CHANNEL_MASK)) {
359
360     case CONVERT (AC3_3F2R, AC3_3F2R):
361         mix1to1 (samples + 1024, level, bias);
362     case CONVERT (AC3_3F1R, AC3_3F1R):
363     case CONVERT (AC3_2F2R, AC3_2F2R):
364         mix1to1 (samples + 768, level, bias);
365     case CONVERT (AC3_3F, AC3_3F):
366     case CONVERT (AC3_2F1R, AC3_2F1R):
367     mix_3to3:
368         mix1to1 (samples + 512, level, bias);
369     case CONVERT (AC3_CHANNEL, AC3_CHANNEL):
370     case CONVERT (AC3_STEREO, AC3_STEREO):
371     case CONVERT (AC3_STEREO, AC3_DOLBY):
372     mix_2to2:
373         mix1to1 (samples + 256, level, bias);
374     case CONVERT (AC3_CHANNEL, AC3_CHANNEL1):
375     case CONVERT (AC3_MONO, AC3_MONO):
376         mix1to1 (samples, level, bias);
377         break;
378
379     case CONVERT (AC3_CHANNEL, AC3_CHANNEL2):
380     mix_1to1_b:
381         mix1to1 (samples + 256, level, bias);
382         break;
383
384     case CONVERT (AC3_STEREO, AC3_MONO):
385     mix_2to1:
386         mix2to1 (samples, level * LEVEL_3DB, bias);
387         break;
388
389     case CONVERT (AC3_2F1R, AC3_MONO):
390         if (slev == 0)
391             goto mix_2to1;
392         mix21to1 (samples, level * LEVEL_3DB, level * slev * LEVEL_3DB, bias);
393         break;
394
395     case CONVERT (AC3_2F2R, AC3_MONO):
396         if (slev == 0)
397             goto mix_2to1;
398         mix22to1 (samples, level * LEVEL_3DB, level * slev * LEVEL_3DB, bias);
399         break;
400
401     case CONVERT (AC3_3F, AC3_MONO):
402     mix_3to1:
403         mix3to1 (samples, level * LEVEL_3DB, level * clev * LEVEL_PLUS3DB,
404                  bias);
405         break;
406
407     case CONVERT (AC3_3F1R, AC3_MONO):
408         if (slev == 0)
409             goto mix_3to1;
410         mix31to1 (samples, level * LEVEL_3DB, level * clev * LEVEL_PLUS3DB,
411                   level * slev * LEVEL_3DB, bias);
412         break;
413
414     case CONVERT (AC3_3F2R, AC3_MONO):
415         if (slev == 0)
416             goto mix_3to1;
417         mix32to1 (samples, level * LEVEL_3DB, level * clev * LEVEL_PLUS3DB,
418                   level * slev * LEVEL_3DB, bias);
419         break;
420
421     case CONVERT (AC3_CHANNEL, AC3_MONO):
422         mix2to1 (samples, level * LEVEL_6DB, bias);
423         break;
424
425     case CONVERT (AC3_MONO, AC3_DOLBY):
426         mix1to2 (samples, samples + 256, level * LEVEL_3DB, bias);
427         break;
428
429     case CONVERT (AC3_3F, AC3_DOLBY):
430         clev = LEVEL_3DB;
431     case CONVERT (AC3_3F, AC3_STEREO):
432     mix_3to2:
433         mix3to2 (samples, level, level * clev, bias);
434         break;
435
436     case CONVERT (AC3_2F1R, AC3_DOLBY):
437         mix21toS (samples, level, level * LEVEL_3DB, bias);
438         break;
439
440     case CONVERT (AC3_3F1R, AC3_DOLBY):
441         mix31toS (samples, level, level * LEVEL_3DB, bias);
442         break;
443
444     case CONVERT (AC3_2F2R, AC3_DOLBY):
445         mix22toS (samples, level, level * LEVEL_3DB, bias);
446         break;
447
448     case CONVERT (AC3_3F2R, AC3_DOLBY):
449         mix32toS (samples, level, level * LEVEL_3DB, bias);
450         break;
451
452     case CONVERT (AC3_2F1R, AC3_STEREO):
453         if (slev == 0)
454             goto mix_2to2;
455         mix21to2 (samples, samples + 256, level, level * slev * LEVEL_3DB,
456                   bias);
457         break;
458
459     case CONVERT (AC3_3F1R, AC3_STEREO):
460         if (slev == 0)
461             goto mix_3to2;
462         mix31to2 (samples, level, level * clev, level * slev * LEVEL_3DB,
463                   bias);
464         break;
465
466     case CONVERT (AC3_2F2R, AC3_STEREO):
467         if (slev == 0)
468             goto mix_2to2;
469         mix11to1 (samples, samples + 512, level, level * slev, bias);
470         mix11to1 (samples + 256, samples + 768, level, level * slev, bias);
471         break;
472
473     case CONVERT (AC3_3F2R, AC3_STEREO):
474         if (slev == 0)
475             goto mix_3to2;
476         mix32to2 (samples, level, level * clev, level * slev, bias);
477         break;
478
479     case CONVERT (AC3_3F1R, AC3_3F):
480         if (slev == 0)
481             goto mix_3to3;
482         mix21to2 (samples, samples + 512, level, level * slev * LEVEL_3DB,
483                   bias);
484
485     case CONVERT (AC3_3F2R, AC3_3F):
486         if (slev == 0)
487             goto mix_3to3;
488         mix11to1 (samples, samples + 768, level, level * slev, bias);
489         mix11to1 (samples + 512, samples + 1024, level, level * slev, bias);
490         goto mix_1to1_b;
491
492     case CONVERT (AC3_2F1R, AC3_2F2R):
493         mix1to2 (samples + 512, samples + 768, level * LEVEL_3DB, bias);
494         goto mix_2to2;
495
496     case CONVERT (AC3_3F1R, AC3_3F2R):
497         mix1to2 (samples + 768, samples + 1024, level * LEVEL_3DB, bias);
498         goto mix_3to3;
499
500     case CONVERT (AC3_2F2R, AC3_2F1R):
501         mix2to1 (samples + 512, level * LEVEL_3DB, bias);
502         goto mix_2to2;
503
504     case CONVERT (AC3_3F2R, AC3_3F1R):
505         mix2to1 (samples + 768, level * LEVEL_3DB, bias);
506         goto mix_3to3;
507
508     case CONVERT (AC3_3F1R, AC3_2F2R):
509         mix3to2 (samples, level, level * clev, bias);
510         mix1to2 (samples + 768, samples + 512, level * LEVEL_3DB, bias);
511         break;
512
513     case CONVERT (AC3_3F1R, AC3_2F1R):
514         mix3to2 (samples, level, level * clev, bias);
515         move1to1 (samples + 768, samples + 512, level, bias);
516         break;
517
518     case CONVERT (AC3_3F2R, AC3_2F1R):
519         mix3to2 (samples, level, level * clev, bias);
520         move2to1 (samples + 768, samples + 512, level * LEVEL_3DB, bias);
521         break;
522
523     case CONVERT (AC3_3F2R, AC3_2F2R):
524         mix3to2 (samples, level, level * clev, bias);
525         move1to1 (samples + 768, samples + 512, level, bias);
526         move1to1 (samples + 1024, samples + 768, level, bias);
527         break;
528
529     }
530 }