cinelerra-5.1/libzmpeg3/a52dec-0.7.3/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 }