Statistics
| Branch: | Revision:

ffmpeg / libavcodec / liba52 / downmix.c @ 5509bffa

History | View | Annotate | Download (16.7 KB)

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22
 */
23
#include "a52.h"
24
#include "a52_internal.h"
25

    
26
#define CONVERT(acmod,output) (((output) << 3) + (acmod))
27

    
28
int a52_downmix_init (int input, int flags, level_t * level,
29
                      level_t clev, level_t slev)
30
{
31
    static uint8_t table[11][8] = {
32
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_STEREO,
33
         A52_STEREO,        A52_STEREO,        A52_STEREO,        A52_STEREO},
34
        {A52_MONO,        A52_MONO,        A52_MONO,        A52_MONO,
35
         A52_MONO,        A52_MONO,        A52_MONO,        A52_MONO},
36
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_STEREO,
37
         A52_STEREO,        A52_STEREO,        A52_STEREO,        A52_STEREO},
38
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_3F,
39
         A52_STEREO,        A52_3F,                A52_STEREO,        A52_3F},
40
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_STEREO,
41
         A52_2F1R,        A52_2F1R,        A52_2F1R,        A52_2F1R},
42
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_STEREO,
43
         A52_2F1R,        A52_3F1R,        A52_2F1R,        A52_3F1R},
44
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_3F,
45
         A52_2F2R,        A52_2F2R,        A52_2F2R,        A52_2F2R},
46
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_3F,
47
         A52_2F2R,        A52_3F2R,        A52_2F2R,        A52_3F2R},
48
        {A52_CHANNEL1,        A52_MONO,        A52_MONO,        A52_MONO,
49
         A52_MONO,        A52_MONO,        A52_MONO,        A52_MONO},
50
        {A52_CHANNEL2,        A52_MONO,        A52_MONO,        A52_MONO,
51
         A52_MONO,        A52_MONO,        A52_MONO,        A52_MONO},
52
        {A52_CHANNEL,        A52_DOLBY,        A52_STEREO,        A52_DOLBY,
53
         A52_DOLBY,        A52_DOLBY,        A52_DOLBY,        A52_DOLBY}
54
    };
55
    int output;
56

    
57
    output = flags & A52_CHANNEL_MASK;
58
    if (output > A52_DOLBY)
59
        return -1;
60

    
61
    output = table[output][input & 7];
62

    
63
    if (output == A52_STEREO &&
64
        (input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB))))
65
        output = A52_DOLBY;
66

    
67
    if (flags & A52_ADJUST_LEVEL) {
68
        level_t adjust;
69

    
70
        switch (CONVERT (input & 7, output)) {
71

    
72
        case CONVERT (A52_3F, A52_MONO):
73
            adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
74
            break;
75

    
76
        case CONVERT (A52_STEREO, A52_MONO):
77
        case CONVERT (A52_2F2R, A52_2F1R):
78
        case CONVERT (A52_3F2R, A52_3F1R):
79
        level_3db:
80
            adjust = LEVEL (LEVEL_3DB);
81
            break;
82

    
83
        case CONVERT (A52_3F2R, A52_2F1R):
84
            if (clev < LEVEL (LEVEL_PLUS3DB - 1))
85
                goto level_3db;
86
            /* break thru */
87
        case CONVERT (A52_3F, A52_STEREO):
88
        case CONVERT (A52_3F1R, A52_2F1R):
89
        case CONVERT (A52_3F1R, A52_2F2R):
90
        case CONVERT (A52_3F2R, A52_2F2R):
91
            adjust = DIV (1, LEVEL (1) + clev);
92
            break;
93

    
94
        case CONVERT (A52_2F1R, A52_MONO):
95
            adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
96
            break;
97

    
98
        case CONVERT (A52_2F1R, A52_STEREO):
99
        case CONVERT (A52_3F1R, A52_3F):
100
            adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
101
            break;
102

    
103
        case CONVERT (A52_3F1R, A52_MONO):
104
            adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
105
            break;
106

    
107
        case CONVERT (A52_3F1R, A52_STEREO):
108
            adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
109
            break;
110

    
111
        case CONVERT (A52_2F2R, A52_MONO):
112
            adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
113
            break;
114

    
115
        case CONVERT (A52_2F2R, A52_STEREO):
116
        case CONVERT (A52_3F2R, A52_3F):
117
            adjust = DIV (1, LEVEL (1) + slev);
118
            break;
119

    
120
        case CONVERT (A52_3F2R, A52_MONO):
121
            adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
122
            break;
123

    
124
        case CONVERT (A52_3F2R, A52_STEREO):
125
            adjust = DIV (1, LEVEL (1) + clev + slev);
126
            break;
127

    
128
        case CONVERT (A52_MONO, A52_DOLBY):
129
            adjust = LEVEL (LEVEL_PLUS3DB);
130
            break;
131

    
132
        case CONVERT (A52_3F, A52_DOLBY):
133
        case CONVERT (A52_2F1R, A52_DOLBY):
134
            adjust = LEVEL (1 / (1 + LEVEL_3DB));
135
            break;
136

    
137
        case CONVERT (A52_3F1R, A52_DOLBY):
138
        case CONVERT (A52_2F2R, A52_DOLBY):
139
            adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
140
            break;
141

    
142
        case CONVERT (A52_3F2R, A52_DOLBY):
143
            adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
144
            break;
145

    
146
        default:
147
            return output;
148
        }
149

    
150
        *level = MUL_L (*level, adjust);
151
    }
152

    
153
    return output;
154
}
155

    
156
int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
157
                       level_t clev, level_t slev)
158
{
159
    level_t level_3db;
160

    
161
    level_3db = MUL_C (level, LEVEL_3DB);
162

    
163
    switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
164

    
165
    case CONVERT (A52_CHANNEL, A52_CHANNEL):
166
    case CONVERT (A52_MONO, A52_MONO):
167
    case CONVERT (A52_STEREO, A52_STEREO):
168
    case CONVERT (A52_3F, A52_3F):
169
    case CONVERT (A52_2F1R, A52_2F1R):
170
    case CONVERT (A52_3F1R, A52_3F1R):
171
    case CONVERT (A52_2F2R, A52_2F2R):
172
    case CONVERT (A52_3F2R, A52_3F2R):
173
    case CONVERT (A52_STEREO, A52_DOLBY):
174
        coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
175
        return 0;
176

    
177
    case CONVERT (A52_CHANNEL, A52_MONO):
178
        coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
179
        return 3;
180

    
181
    case CONVERT (A52_STEREO, A52_MONO):
182
        coeff[0] = coeff[1] = level_3db;
183
        return 3;
184

    
185
    case CONVERT (A52_3F, A52_MONO):
186
        coeff[0] = coeff[2] = level_3db;
187
        coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
188
        return 7;
189

    
190
    case CONVERT (A52_2F1R, A52_MONO):
191
        coeff[0] = coeff[1] = level_3db;
192
        coeff[2] = MUL_L (level_3db, slev);
193
        return 7;
194

    
195
    case CONVERT (A52_2F2R, A52_MONO):
196
        coeff[0] = coeff[1] = level_3db;
197
        coeff[2] = coeff[3] = MUL_L (level_3db, slev);
198
        return 15;
199

    
200
    case CONVERT (A52_3F1R, A52_MONO):
201
        coeff[0] = coeff[2] = level_3db;
202
        coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
203
        coeff[3] = MUL_L (level_3db, slev);
204
        return 15;
205

    
206
    case CONVERT (A52_3F2R, A52_MONO):
207
        coeff[0] = coeff[2] = level_3db;
208
        coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
209
        coeff[3] = coeff[4] = MUL_L (level_3db, slev);
210
        return 31;
211

    
212
    case CONVERT (A52_MONO, A52_DOLBY):
213
        coeff[0] = level_3db;
214
        return 0;
215

    
216
    case CONVERT (A52_3F, A52_DOLBY):
217
        coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
218
        coeff[1] = level_3db;
219
        return 7;
220

    
221
    case CONVERT (A52_3F, A52_STEREO):
222
    case CONVERT (A52_3F1R, A52_2F1R):
223
    case CONVERT (A52_3F2R, A52_2F2R):
224
        coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
225
        coeff[1] = MUL_L (level, clev);
226
        return 7;
227

    
228
    case CONVERT (A52_2F1R, A52_DOLBY):
229
        coeff[0] = coeff[1] = level;
230
        coeff[2] = level_3db;
231
        return 7;
232

    
233
    case CONVERT (A52_2F1R, A52_STEREO):
234
        coeff[0] = coeff[1] = level;
235
        coeff[2] = MUL_L (level_3db, slev);
236
        return 7;
237

    
238
    case CONVERT (A52_3F1R, A52_DOLBY):
239
        coeff[0] = coeff[2] = level;
240
        coeff[1] = coeff[3] = level_3db;
241
        return 15;
242

    
243
    case CONVERT (A52_3F1R, A52_STEREO):
244
        coeff[0] = coeff[2] = level;
245
        coeff[1] = MUL_L (level, clev);
246
        coeff[3] = MUL_L (level_3db, slev);
247
        return 15;
248

    
249
    case CONVERT (A52_2F2R, A52_DOLBY):
250
        coeff[0] = coeff[1] = level;
251
        coeff[2] = coeff[3] = level_3db;
252
        return 15;
253

    
254
    case CONVERT (A52_2F2R, A52_STEREO):
255
        coeff[0] = coeff[1] = level;
256
        coeff[2] = coeff[3] = MUL_L (level, slev);
257
        return 15;
258

    
259
    case CONVERT (A52_3F2R, A52_DOLBY):
260
        coeff[0] = coeff[2] = level;
261
        coeff[1] = coeff[3] = coeff[4] = level_3db;
262
        return 31;
263

    
264
    case CONVERT (A52_3F2R, A52_2F1R):
265
        coeff[0] = coeff[2] = level;
266
        coeff[1] = MUL_L (level, clev);
267
        coeff[3] = coeff[4] = level_3db;
268
        return 31;
269

    
270
    case CONVERT (A52_3F2R, A52_STEREO):
271
        coeff[0] = coeff[2] = level;
272
        coeff[1] = MUL_L (level, clev);
273
        coeff[3] = coeff[4] = MUL_L (level, slev);
274
        return 31;
275

    
276
    case CONVERT (A52_3F1R, A52_3F):
277
        coeff[0] = coeff[1] = coeff[2] = level;
278
        coeff[3] = MUL_L (level_3db, slev);
279
        return 13;
280

    
281
    case CONVERT (A52_3F2R, A52_3F):
282
        coeff[0] = coeff[1] = coeff[2] = level;
283
        coeff[3] = coeff[4] = MUL_L (level, slev);
284
        return 29;
285

    
286
    case CONVERT (A52_2F2R, A52_2F1R):
287
        coeff[0] = coeff[1] = level;
288
        coeff[2] = coeff[3] = level_3db;
289
        return 12;
290

    
291
    case CONVERT (A52_3F2R, A52_3F1R):
292
        coeff[0] = coeff[1] = coeff[2] = level;
293
        coeff[3] = coeff[4] = level_3db;
294
        return 24;
295

    
296
    case CONVERT (A52_2F1R, A52_2F2R):
297
        coeff[0] = coeff[1] = level;
298
        coeff[2] = level_3db;
299
        return 0;
300

    
301
    case CONVERT (A52_3F1R, A52_2F2R):
302
        coeff[0] = coeff[2] = level;
303
        coeff[1] = MUL_L (level, clev);
304
        coeff[3] = level_3db;
305
        return 7;
306

    
307
    case CONVERT (A52_3F1R, A52_3F2R):
308
        coeff[0] = coeff[1] = coeff[2] = level;
309
        coeff[3] = level_3db;
310
        return 0;
311

    
312
    case CONVERT (A52_CHANNEL, A52_CHANNEL1):
313
        coeff[0] = level;
314
        coeff[1] = 0;
315
        return 0;
316

    
317
    case CONVERT (A52_CHANNEL, A52_CHANNEL2):
318
        coeff[0] = 0;
319
        coeff[1] = level;
320
        return 0;
321
    }
322

    
323
    return -1;        /* NOTREACHED */
324
}
325

    
326
static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
327
{
328
    int i;
329

    
330
    for (i = 0; i < 256; i++)
331
        dest[i] += BIAS (src[i]);
332
}
333

    
334
static void mix3to1 (sample_t * samples, sample_t bias)
335
{
336
    int i;
337

    
338
    for (i = 0; i < 256; i++)
339
        samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
340
}
341

    
342
static void mix4to1 (sample_t * samples, sample_t bias)
343
{
344
    int i;
345

    
346
    for (i = 0; i < 256; i++)
347
        samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
348
                            samples[i + 768]);
349
}
350

    
351
static void mix5to1 (sample_t * samples, sample_t bias)
352
{
353
    int i;
354

    
355
    for (i = 0; i < 256; i++)
356
        samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
357
                            samples[i + 768] + samples[i + 1024]);
358
}
359

    
360
static void mix3to2 (sample_t * samples, sample_t bias)
361
{
362
    int i;
363
    sample_t common;
364

    
365
    for (i = 0; i < 256; i++) {
366
        common = BIAS (samples[i + 256]);
367
        samples[i] += common;
368
        samples[i + 256] = samples[i + 512] + common;
369
    }
370
}
371

    
372
static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
373
{
374
    int i;
375
    sample_t common;
376

    
377
    for (i = 0; i < 256; i++) {
378
        common = BIAS (right[i + 256]);
379
        left[i] += common;
380
        right[i] += common;
381
    }
382
}
383

    
384
static void mix21toS (sample_t * samples, sample_t bias)
385
{
386
    int i;
387
    sample_t surround;
388

    
389
    for (i = 0; i < 256; i++) {
390
        surround = samples[i + 512];
391
        samples[i] += BIAS (-surround);
392
        samples[i + 256] += BIAS (surround);
393
    }
394
}
395

    
396
static void mix31to2 (sample_t * samples, sample_t bias)
397
{
398
    int i;
399
    sample_t common;
400

    
401
    for (i = 0; i < 256; i++) {
402
        common = BIAS (samples[i + 256] + samples[i + 768]);
403
        samples[i] += common;
404
        samples[i + 256] = samples[i + 512] + common;
405
    }
406
}
407

    
408
static void mix31toS (sample_t * samples, sample_t bias)
409
{
410
    int i;
411
    sample_t common, surround;
412

    
413
    for (i = 0; i < 256; i++) {
414
        common = BIAS (samples[i + 256]);
415
        surround = samples[i + 768];
416
        samples[i] += common - surround;
417
        samples[i + 256] = samples[i + 512] + common + surround;
418
    }
419
}
420

    
421
static void mix22toS (sample_t * samples, sample_t bias)
422
{
423
    int i;
424
    sample_t surround;
425

    
426
    for (i = 0; i < 256; i++) {
427
        surround = samples[i + 512] + samples[i + 768];
428
        samples[i] += BIAS (-surround);
429
        samples[i + 256] += BIAS (surround);
430
    }
431
}
432

    
433
static void mix32to2 (sample_t * samples, sample_t bias)
434
{
435
    int i;
436
    sample_t common;
437

    
438
    for (i = 0; i < 256; i++) {
439
        common = BIAS (samples[i + 256]);
440
        samples[i] += common + samples[i + 768];
441
        samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
442
    }
443
}
444

    
445
static void mix32toS (sample_t * samples, sample_t bias)
446
{
447
    int i;
448
    sample_t common, surround;
449

    
450
    for (i = 0; i < 256; i++) {
451
        common = BIAS (samples[i + 256]);
452
        surround = samples[i + 768] + samples[i + 1024];
453
        samples[i] += common - surround;
454
        samples[i + 256] = samples[i + 512] + common + surround;
455
    }
456
}
457

    
458
static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
459
{
460
    int i;
461

    
462
    for (i = 0; i < 256; i++)
463
        dest[i] = BIAS (src[i] + src[i + 256]);
464
}
465

    
466
static void zero (sample_t * samples)
467
{
468
    int i;
469

    
470
    for (i = 0; i < 256; i++)
471
        samples[i] = 0;
472
}
473

    
474
void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
475
                  level_t clev, level_t slev)
476
{
477
    switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
478

    
479
    case CONVERT (A52_CHANNEL, A52_CHANNEL2):
480
        memcpy (samples, samples + 256, 256 * sizeof (sample_t));
481
        break;
482

    
483
    case CONVERT (A52_CHANNEL, A52_MONO):
484
    case CONVERT (A52_STEREO, A52_MONO):
485
    mix_2to1:
486
        mix2to1 (samples, samples + 256, bias);
487
        break;
488

    
489
    case CONVERT (A52_2F1R, A52_MONO):
490
        if (slev == 0)
491
            goto mix_2to1;
492
    case CONVERT (A52_3F, A52_MONO):
493
    mix_3to1:
494
        mix3to1 (samples, bias);
495
        break;
496

    
497
    case CONVERT (A52_3F1R, A52_MONO):
498
        if (slev == 0)
499
            goto mix_3to1;
500
    case CONVERT (A52_2F2R, A52_MONO):
501
        if (slev == 0)
502
            goto mix_2to1;
503
        mix4to1 (samples, bias);
504
        break;
505

    
506
    case CONVERT (A52_3F2R, A52_MONO):
507
        if (slev == 0)
508
            goto mix_3to1;
509
        mix5to1 (samples, bias);
510
        break;
511

    
512
    case CONVERT (A52_MONO, A52_DOLBY):
513
        memcpy (samples + 256, samples, 256 * sizeof (sample_t));
514
        break;
515

    
516
    case CONVERT (A52_3F, A52_STEREO):
517
    case CONVERT (A52_3F, A52_DOLBY):
518
    mix_3to2:
519
        mix3to2 (samples, bias);
520
        break;
521

    
522
    case CONVERT (A52_2F1R, A52_STEREO):
523
        if (slev == 0)
524
            break;
525
        mix21to2 (samples, samples + 256, bias);
526
        break;
527

    
528
    case CONVERT (A52_2F1R, A52_DOLBY):
529
        mix21toS (samples, bias);
530
        break;
531

    
532
    case CONVERT (A52_3F1R, A52_STEREO):
533
        if (slev == 0)
534
            goto mix_3to2;
535
        mix31to2 (samples, bias);
536
        break;
537

    
538
    case CONVERT (A52_3F1R, A52_DOLBY):
539
        mix31toS (samples, bias);
540
        break;
541

    
542
    case CONVERT (A52_2F2R, A52_STEREO):
543
        if (slev == 0)
544
            break;
545
        mix2to1 (samples, samples + 512, bias);
546
        mix2to1 (samples + 256, samples + 768, bias);
547
        break;
548

    
549
    case CONVERT (A52_2F2R, A52_DOLBY):
550
        mix22toS (samples, bias);
551
        break;
552

    
553
    case CONVERT (A52_3F2R, A52_STEREO):
554
        if (slev == 0)
555
            goto mix_3to2;
556
        mix32to2 (samples, bias);
557
        break;
558

    
559
    case CONVERT (A52_3F2R, A52_DOLBY):
560
        mix32toS (samples, bias);
561
        break;
562

    
563
    case CONVERT (A52_3F1R, A52_3F):
564
        if (slev == 0)
565
            break;
566
        mix21to2 (samples, samples + 512, bias);
567
        break;
568

    
569
    case CONVERT (A52_3F2R, A52_3F):
570
        if (slev == 0)
571
            break;
572
        mix2to1 (samples, samples + 768, bias);
573
        mix2to1 (samples + 512, samples + 1024, bias);
574
        break;
575

    
576
    case CONVERT (A52_3F1R, A52_2F1R):
577
        mix3to2 (samples, bias);
578
        memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
579
        break;
580

    
581
    case CONVERT (A52_2F2R, A52_2F1R):
582
        mix2to1 (samples + 512, samples + 768, bias);
583
        break;
584

    
585
    case CONVERT (A52_3F2R, A52_2F1R):
586
        mix3to2 (samples, bias);
587
        move2to1 (samples + 768, samples + 512, bias);
588
        break;
589

    
590
    case CONVERT (A52_3F2R, A52_3F1R):
591
        mix2to1 (samples + 768, samples + 1024, bias);
592
        break;
593

    
594
    case CONVERT (A52_2F1R, A52_2F2R):
595
        memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
596
        break;
597

    
598
    case CONVERT (A52_3F1R, A52_2F2R):
599
        mix3to2 (samples, bias);
600
        memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
601
        break;
602

    
603
    case CONVERT (A52_3F2R, A52_2F2R):
604
        mix3to2 (samples, bias);
605
        memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
606
        memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
607
        break;
608

    
609
    case CONVERT (A52_3F1R, A52_3F2R):
610
        memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
611
        break;
612
    }
613
}
614

    
615
void a52_upmix (sample_t * samples, int acmod, int output)
616
{
617
    switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
618

    
619
    case CONVERT (A52_CHANNEL, A52_CHANNEL2):
620
        memcpy (samples + 256, samples, 256 * sizeof (sample_t));
621
        break;
622

    
623
    case CONVERT (A52_3F2R, A52_MONO):
624
        zero (samples + 1024);
625
    case CONVERT (A52_3F1R, A52_MONO):
626
    case CONVERT (A52_2F2R, A52_MONO):
627
        zero (samples + 768);
628
    case CONVERT (A52_3F, A52_MONO):
629
    case CONVERT (A52_2F1R, A52_MONO):
630
        zero (samples + 512);
631
    case CONVERT (A52_CHANNEL, A52_MONO):
632
    case CONVERT (A52_STEREO, A52_MONO):
633
        zero (samples + 256);
634
        break;
635

    
636
    case CONVERT (A52_3F2R, A52_STEREO):
637
    case CONVERT (A52_3F2R, A52_DOLBY):
638
        zero (samples + 1024);
639
    case CONVERT (A52_3F1R, A52_STEREO):
640
    case CONVERT (A52_3F1R, A52_DOLBY):
641
        zero (samples + 768);
642
    case CONVERT (A52_3F, A52_STEREO):
643
    case CONVERT (A52_3F, A52_DOLBY):
644
    mix_3to2:
645
        memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
646
        zero (samples + 256);
647
        break;
648

    
649
    case CONVERT (A52_2F2R, A52_STEREO):
650
    case CONVERT (A52_2F2R, A52_DOLBY):
651
        zero (samples + 768);
652
    case CONVERT (A52_2F1R, A52_STEREO):
653
    case CONVERT (A52_2F1R, A52_DOLBY):
654
        zero (samples + 512);
655
        break;
656

    
657
    case CONVERT (A52_3F2R, A52_3F):
658
        zero (samples + 1024);
659
    case CONVERT (A52_3F1R, A52_3F):
660
    case CONVERT (A52_2F2R, A52_2F1R):
661
        zero (samples + 768);
662
        break;
663

    
664
    case CONVERT (A52_3F2R, A52_3F1R):
665
        zero (samples + 1024);
666
        break;
667

    
668
    case CONVERT (A52_3F2R, A52_2F1R):
669
        zero (samples + 1024);
670
    case CONVERT (A52_3F1R, A52_2F1R):
671
    mix_31to21:
672
        memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
673
        goto mix_3to2;
674

    
675
    case CONVERT (A52_3F2R, A52_2F2R):
676
        memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
677
        goto mix_31to21;
678
    }
679
}