git.sesse.net Git - ffmpeg/blob - libavcodec/liba52/downmix.c

   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.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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias)
 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, sample_t bias,
 481                   level_t clev, level_t slev)
 482 {
 483     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
 484
 485     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
 486         memcpy (samples, samples + 256, 256 * sizeof (sample_t));
 487         break;
 488
 489     case CONVERT (A52_CHANNEL, A52_MONO):
 490     case CONVERT (A52_STEREO, A52_MONO):
 491     mix_2to1:
 492         mix2to1 (samples, samples + 256, bias);
 493         break;
 494
 495     case CONVERT (A52_2F1R, A52_MONO):
 496         if (slev == 0)
 497             goto mix_2to1;
 498     case CONVERT (A52_3F, A52_MONO):
 499     mix_3to1:
 500         mix3to1 (samples, bias);
 501         break;
 502
 503     case CONVERT (A52_3F1R, A52_MONO):
 504         if (slev == 0)
 505             goto mix_3to1;
 506     case CONVERT (A52_2F2R, A52_MONO):
 507         if (slev == 0)
 508             goto mix_2to1;
 509         mix4to1 (samples, bias);
 510         break;
 511
 512     case CONVERT (A52_3F2R, A52_MONO):
 513         if (slev == 0)
 514             goto mix_3to1;
 515         mix5to1 (samples, bias);
 516         break;
 517
 518     case CONVERT (A52_MONO, A52_DOLBY):
 519         memcpy (samples + 256, samples, 256 * sizeof (sample_t));
 520         break;
 521
 522     case CONVERT (A52_3F, A52_STEREO):
 523     case CONVERT (A52_3F, A52_DOLBY):
 524     mix_3to2:
 525         mix3to2 (samples, bias);
 526         break;
 527
 528     case CONVERT (A52_2F1R, A52_STEREO):
 529         if (slev == 0)
 530             break;
 531         mix21to2 (samples, samples + 256, bias);
 532         break;
 533
 534     case CONVERT (A52_2F1R, A52_DOLBY):
 535         mix21toS (samples, bias);
 536         break;
 537
 538     case CONVERT (A52_3F1R, A52_STEREO):
 539         if (slev == 0)
 540             goto mix_3to2;
 541         mix31to2 (samples, bias);
 542         break;
 543
 544     case CONVERT (A52_3F1R, A52_DOLBY):
 545         mix31toS (samples, bias);
 546         break;
 547
 548     case CONVERT (A52_2F2R, A52_STEREO):
 549         if (slev == 0)
 550             break;
 551         mix2to1 (samples, samples + 512, bias);
 552         mix2to1 (samples + 256, samples + 768, bias);
 553         break;
 554
 555     case CONVERT (A52_2F2R, A52_DOLBY):
 556         mix22toS (samples, bias);
 557         break;
 558
 559     case CONVERT (A52_3F2R, A52_STEREO):
 560         if (slev == 0)
 561             goto mix_3to2;
 562         mix32to2 (samples, bias);
 563         break;
 564
 565     case CONVERT (A52_3F2R, A52_DOLBY):
 566         mix32toS (samples, bias);
 567         break;
 568
 569     case CONVERT (A52_3F1R, A52_3F):
 570         if (slev == 0)
 571             break;
 572         mix21to2 (samples, samples + 512, bias);
 573         break;
 574
 575     case CONVERT (A52_3F2R, A52_3F):
 576         if (slev == 0)
 577             break;
 578         mix2to1 (samples, samples + 768, bias);
 579         mix2to1 (samples + 512, samples + 1024, bias);
 580         break;
 581
 582     case CONVERT (A52_3F1R, A52_2F1R):
 583         mix3to2 (samples, bias);
 584         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
 585         break;
 586
 587     case CONVERT (A52_2F2R, A52_2F1R):
 588         mix2to1 (samples + 512, samples + 768, bias);
 589         break;
 590
 591     case CONVERT (A52_3F2R, A52_2F1R):
 592         mix3to2 (samples, bias);
 593         move2to1 (samples + 768, samples + 512, bias);
 594         break;
 595
 596     case CONVERT (A52_3F2R, A52_3F1R):
 597         mix2to1 (samples + 768, samples + 1024, bias);
 598         break;
 599
 600     case CONVERT (A52_2F1R, A52_2F2R):
 601         memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
 602         break;
 603
 604     case CONVERT (A52_3F1R, A52_2F2R):
 605         mix3to2 (samples, bias);
 606         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
 607         break;
 608
 609     case CONVERT (A52_3F2R, A52_2F2R):
 610         mix3to2 (samples, bias);
 611         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
 612         memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
 613         break;
 614
 615     case CONVERT (A52_3F1R, A52_3F2R):
 616         memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
 617         break;
 618     }
 619 }
 620
 621 void a52_upmix (sample_t * samples, int acmod, int output)
 622 {
 623     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
 624
 625     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
 626         memcpy (samples + 256, samples, 256 * sizeof (sample_t));
 627         break;
 628
 629     case CONVERT (A52_3F2R, A52_MONO):
 630         zero (samples + 1024);
 631     case CONVERT (A52_3F1R, A52_MONO):
 632     case CONVERT (A52_2F2R, A52_MONO):
 633         zero (samples + 768);
 634     case CONVERT (A52_3F, A52_MONO):
 635     case CONVERT (A52_2F1R, A52_MONO):
 636         zero (samples + 512);
 637     case CONVERT (A52_CHANNEL, A52_MONO):
 638     case CONVERT (A52_STEREO, A52_MONO):
 639         zero (samples + 256);
 640         break;
 641
 642     case CONVERT (A52_3F2R, A52_STEREO):
 643     case CONVERT (A52_3F2R, A52_DOLBY):
 644         zero (samples + 1024);
 645     case CONVERT (A52_3F1R, A52_STEREO):
 646     case CONVERT (A52_3F1R, A52_DOLBY):
 647         zero (samples + 768);
 648     case CONVERT (A52_3F, A52_STEREO):
 649     case CONVERT (A52_3F, A52_DOLBY):
 650     mix_3to2:
 651         memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
 652         zero (samples + 256);
 653         break;
 654
 655     case CONVERT (A52_2F2R, A52_STEREO):
 656     case CONVERT (A52_2F2R, A52_DOLBY):
 657         zero (samples + 768);
 658     case CONVERT (A52_2F1R, A52_STEREO):
 659     case CONVERT (A52_2F1R, A52_DOLBY):
 660         zero (samples + 512);
 661         break;
 662
 663     case CONVERT (A52_3F2R, A52_3F):
 664         zero (samples + 1024);
 665     case CONVERT (A52_3F1R, A52_3F):
 666     case CONVERT (A52_2F2R, A52_2F1R):
 667         zero (samples + 768);
 668         break;
 669
 670     case CONVERT (A52_3F2R, A52_3F1R):
 671         zero (samples + 1024);
 672         break;
 673
 674     case CONVERT (A52_3F2R, A52_2F1R):
 675         zero (samples + 1024);
 676     case CONVERT (A52_3F1R, A52_2F1R):
 677     mix_31to21:
 678         memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
 679         goto mix_3to2;
 680
 681     case CONVERT (A52_3F2R, A52_2F2R):
 682         memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
 683         goto mix_31to21;
 684     }
 685 }