Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/liba52/downmix.c Source File

00001 /*
00002  * downmix.c
00003  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
00004  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
00005  *
00006  * This file is part of a52dec, a free ATSC A-52 stream decoder.
00007  * See http://liba52.sourceforge.net/ for updates.
00008  *
00009  * a52dec is free software; you can redistribute it and/or modify
00010  * it under the terms of the GNU General Public License as published by
00011  * the Free Software Foundation; either version 2 of the License, or
00012  * (at your option) any later version.
00013  *
00014  * a52dec is distributed in the hope that it will be useful,
00015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017  * GNU General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU General Public License
00020  * along with this program; if not, write to the Free Software
00021  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022  */
00023 #include "a52.h"
00024 #include "a52_internal.h"
00025 
00026 #define CONVERT(acmod,output) (((output) << 3) + (acmod))
00027 
00028 int a52_downmix_init (int input, int flags, level_t * level,
00029                       level_t clev, level_t slev)
00030 {
00031     static uint8_t table[11][8] = {
00032         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_STEREO,
00033          A52_STEREO,    A52_STEREO,     A52_STEREO,     A52_STEREO},
00034         {A52_MONO,      A52_MONO,       A52_MONO,       A52_MONO,
00035          A52_MONO,      A52_MONO,       A52_MONO,       A52_MONO},
00036         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_STEREO,
00037          A52_STEREO,    A52_STEREO,     A52_STEREO,     A52_STEREO},
00038         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_3F,
00039          A52_STEREO,    A52_3F,         A52_STEREO,     A52_3F},
00040         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_STEREO,
00041          A52_2F1R,      A52_2F1R,       A52_2F1R,       A52_2F1R},
00042         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_STEREO,
00043          A52_2F1R,      A52_3F1R,       A52_2F1R,       A52_3F1R},
00044         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_3F,
00045          A52_2F2R,      A52_2F2R,       A52_2F2R,       A52_2F2R},
00046         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_3F,
00047          A52_2F2R,      A52_3F2R,       A52_2F2R,       A52_3F2R},
00048         {A52_CHANNEL1,  A52_MONO,       A52_MONO,       A52_MONO,
00049          A52_MONO,      A52_MONO,       A52_MONO,       A52_MONO},
00050         {A52_CHANNEL2,  A52_MONO,       A52_MONO,       A52_MONO,
00051          A52_MONO,      A52_MONO,       A52_MONO,       A52_MONO},
00052         {A52_CHANNEL,   A52_DOLBY,      A52_STEREO,     A52_DOLBY,
00053          A52_DOLBY,     A52_DOLBY,      A52_DOLBY,      A52_DOLBY}
00054     };
00055     int output;
00056 
00057     output = flags & A52_CHANNEL_MASK;
00058     if (output > A52_DOLBY)
00059         return -1;
00060 
00061     output = table[output][input & 7];
00062 
00063     if (output == A52_STEREO &&
00064         (input == A52_DOLBY || (input == A52_3F && clev == LEVEL (LEVEL_3DB))))
00065         output = A52_DOLBY;
00066 
00067     if (flags & A52_ADJUST_LEVEL) {
00068         level_t adjust;
00069 
00070         switch (CONVERT (input & 7, output)) {
00071 
00072         case CONVERT (A52_3F, A52_MONO):
00073             adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
00074             break;
00075 
00076         case CONVERT (A52_STEREO, A52_MONO):
00077         case CONVERT (A52_2F2R, A52_2F1R):
00078         case CONVERT (A52_3F2R, A52_3F1R):
00079         level_3db:
00080             adjust = LEVEL (LEVEL_3DB);
00081             break;
00082 
00083         case CONVERT (A52_3F2R, A52_2F1R):
00084             if (clev < LEVEL (LEVEL_PLUS3DB - 1))
00085                 goto level_3db;
00086             /* break thru */
00087         case CONVERT (A52_3F, A52_STEREO):
00088         case CONVERT (A52_3F1R, A52_2F1R):
00089         case CONVERT (A52_3F1R, A52_2F2R):
00090         case CONVERT (A52_3F2R, A52_2F2R):
00091             adjust = DIV (1, LEVEL (1) + clev);
00092             break;
00093 
00094         case CONVERT (A52_2F1R, A52_MONO):
00095             adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
00096             break;
00097 
00098         case CONVERT (A52_2F1R, A52_STEREO):
00099         case CONVERT (A52_3F1R, A52_3F):
00100             adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
00101             break;
00102 
00103         case CONVERT (A52_3F1R, A52_MONO):
00104             adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
00105             break;
00106 
00107         case CONVERT (A52_3F1R, A52_STEREO):
00108             adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
00109             break;
00110 
00111         case CONVERT (A52_2F2R, A52_MONO):
00112             adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
00113             break;
00114 
00115         case CONVERT (A52_2F2R, A52_STEREO):
00116         case CONVERT (A52_3F2R, A52_3F):
00117             adjust = DIV (1, LEVEL (1) + slev);
00118             break;
00119 
00120         case CONVERT (A52_3F2R, A52_MONO):
00121             adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
00122             break;
00123 
00124         case CONVERT (A52_3F2R, A52_STEREO):
00125             adjust = DIV (1, LEVEL (1) + clev + slev);
00126             break;
00127 
00128         case CONVERT (A52_MONO, A52_DOLBY):
00129             adjust = LEVEL (LEVEL_PLUS3DB);
00130             break;
00131 
00132         case CONVERT (A52_3F, A52_DOLBY):
00133         case CONVERT (A52_2F1R, A52_DOLBY):
00134             adjust = LEVEL (1 / (1 + LEVEL_3DB));
00135             break;
00136 
00137         case CONVERT (A52_3F1R, A52_DOLBY):
00138         case CONVERT (A52_2F2R, A52_DOLBY):
00139             adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
00140             break;
00141 
00142         case CONVERT (A52_3F2R, A52_DOLBY):
00143             adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
00144             break;
00145 
00146         default:
00147             return output;
00148         }
00149 
00150         *level = MUL_L (*level, adjust);
00151     }
00152 
00153     return output;
00154 }
00155 
00156 int a52_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
00157                        level_t clev, level_t slev)
00158 {
00159     level_t level_3db;
00160 
00161     level_3db = MUL_C (level, LEVEL_3DB);
00162 
00163     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
00164 
00165     case CONVERT (A52_CHANNEL, A52_CHANNEL):
00166     case CONVERT (A52_MONO, A52_MONO):
00167     case CONVERT (A52_STEREO, A52_STEREO):
00168     case CONVERT (A52_3F, A52_3F):
00169     case CONVERT (A52_2F1R, A52_2F1R):
00170     case CONVERT (A52_3F1R, A52_3F1R):
00171     case CONVERT (A52_2F2R, A52_2F2R):
00172     case CONVERT (A52_3F2R, A52_3F2R):
00173     case CONVERT (A52_STEREO, A52_DOLBY):
00174         coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
00175         return 0;
00176 
00177     case CONVERT (A52_CHANNEL, A52_MONO):
00178         coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
00179         return 3;
00180 
00181     case CONVERT (A52_STEREO, A52_MONO):
00182         coeff[0] = coeff[1] = level_3db;
00183         return 3;
00184 
00185     case CONVERT (A52_3F, A52_MONO):
00186         coeff[0] = coeff[2] = level_3db;
00187         coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
00188         return 7;
00189 
00190     case CONVERT (A52_2F1R, A52_MONO):
00191         coeff[0] = coeff[1] = level_3db;
00192         coeff[2] = MUL_L (level_3db, slev);
00193         return 7;
00194 
00195     case CONVERT (A52_2F2R, A52_MONO):
00196         coeff[0] = coeff[1] = level_3db;
00197         coeff[2] = coeff[3] = MUL_L (level_3db, slev);
00198         return 15;
00199 
00200     case CONVERT (A52_3F1R, A52_MONO):
00201         coeff[0] = coeff[2] = level_3db;
00202         coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
00203         coeff[3] = MUL_L (level_3db, slev);
00204         return 15;
00205 
00206     case CONVERT (A52_3F2R, A52_MONO):
00207         coeff[0] = coeff[2] = level_3db;
00208         coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
00209         coeff[3] = coeff[4] = MUL_L (level_3db, slev);
00210         return 31;
00211 
00212     case CONVERT (A52_MONO, A52_DOLBY):
00213         coeff[0] = level_3db;
00214         return 0;
00215 
00216     case CONVERT (A52_3F, A52_DOLBY):
00217         coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
00218         coeff[1] = level_3db;
00219         return 7;
00220 
00221     case CONVERT (A52_3F, A52_STEREO):
00222     case CONVERT (A52_3F1R, A52_2F1R):
00223     case CONVERT (A52_3F2R, A52_2F2R):
00224         coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
00225         coeff[1] = MUL_L (level, clev);
00226         return 7;
00227 
00228     case CONVERT (A52_2F1R, A52_DOLBY):
00229         coeff[0] = coeff[1] = level;
00230         coeff[2] = level_3db;
00231         return 7;
00232 
00233     case CONVERT (A52_2F1R, A52_STEREO):
00234         coeff[0] = coeff[1] = level;
00235         coeff[2] = MUL_L (level_3db, slev);
00236         return 7;
00237 
00238     case CONVERT (A52_3F1R, A52_DOLBY):
00239         coeff[0] = coeff[2] = level;
00240         coeff[1] = coeff[3] = level_3db;
00241         return 15;
00242 
00243     case CONVERT (A52_3F1R, A52_STEREO):
00244         coeff[0] = coeff[2] = level;
00245         coeff[1] = MUL_L (level, clev);
00246         coeff[3] = MUL_L (level_3db, slev);
00247         return 15;
00248 
00249     case CONVERT (A52_2F2R, A52_DOLBY):
00250         coeff[0] = coeff[1] = level;
00251         coeff[2] = coeff[3] = level_3db;
00252         return 15;
00253 
00254     case CONVERT (A52_2F2R, A52_STEREO):
00255         coeff[0] = coeff[1] = level;
00256         coeff[2] = coeff[3] = MUL_L (level, slev);
00257         return 15;
00258 
00259     case CONVERT (A52_3F2R, A52_DOLBY):
00260         coeff[0] = coeff[2] = level;
00261         coeff[1] = coeff[3] = coeff[4] = level_3db;
00262         return 31;
00263 
00264     case CONVERT (A52_3F2R, A52_2F1R):
00265         coeff[0] = coeff[2] = level;
00266         coeff[1] = MUL_L (level, clev);
00267         coeff[3] = coeff[4] = level_3db;
00268         return 31;
00269 
00270     case CONVERT (A52_3F2R, A52_STEREO):
00271         coeff[0] = coeff[2] = level;
00272         coeff[1] = MUL_L (level, clev);
00273         coeff[3] = coeff[4] = MUL_L (level, slev);
00274         return 31;
00275 
00276     case CONVERT (A52_3F1R, A52_3F):
00277         coeff[0] = coeff[1] = coeff[2] = level;
00278         coeff[3] = MUL_L (level_3db, slev);
00279         return 13;
00280 
00281     case CONVERT (A52_3F2R, A52_3F):
00282         coeff[0] = coeff[1] = coeff[2] = level;
00283         coeff[3] = coeff[4] = MUL_L (level, slev);
00284         return 29;
00285 
00286     case CONVERT (A52_2F2R, A52_2F1R):
00287         coeff[0] = coeff[1] = level;
00288         coeff[2] = coeff[3] = level_3db;
00289         return 12;
00290 
00291     case CONVERT (A52_3F2R, A52_3F1R):
00292         coeff[0] = coeff[1] = coeff[2] = level;
00293         coeff[3] = coeff[4] = level_3db;
00294         return 24;
00295 
00296     case CONVERT (A52_2F1R, A52_2F2R):
00297         coeff[0] = coeff[1] = level;
00298         coeff[2] = level_3db;
00299         return 0;
00300 
00301     case CONVERT (A52_3F1R, A52_2F2R):
00302         coeff[0] = coeff[2] = level;
00303         coeff[1] = MUL_L (level, clev);
00304         coeff[3] = level_3db;
00305         return 7;
00306 
00307     case CONVERT (A52_3F1R, A52_3F2R):
00308         coeff[0] = coeff[1] = coeff[2] = level;
00309         coeff[3] = level_3db;
00310         return 0;
00311 
00312     case CONVERT (A52_CHANNEL, A52_CHANNEL1):
00313         coeff[0] = level;
00314         coeff[1] = 0;
00315         return 0;
00316 
00317     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
00318         coeff[0] = 0;
00319         coeff[1] = level;
00320         return 0;
00321     }
00322 
00323     return -1;  /* NOTREACHED */
00324 }
00325 
00326 static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
00327 {
00328     int i;
00329 
00330     for (i = 0; i < 256; i++)
00331         dest[i] += BIAS (src[i]);
00332 }
00333 
00334 static void mix3to1 (sample_t * samples, sample_t bias)
00335 {
00336     int i;
00337 
00338     for (i = 0; i < 256; i++)
00339         samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
00340 }
00341 
00342 static void mix4to1 (sample_t * samples, sample_t bias)
00343 {
00344     int i;
00345 
00346     for (i = 0; i < 256; i++)
00347         samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
00348                             samples[i + 768]);
00349 }
00350 
00351 static void mix5to1 (sample_t * samples, sample_t bias)
00352 {
00353     int i;
00354 
00355     for (i = 0; i < 256; i++)
00356         samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
00357                             samples[i + 768] + samples[i + 1024]);
00358 }
00359 
00360 static void mix3to2 (sample_t * samples, sample_t bias)
00361 {
00362     int i;
00363     sample_t common;
00364 
00365     for (i = 0; i < 256; i++) {
00366         common = BIAS (samples[i + 256]);
00367         samples[i] += common;
00368         samples[i + 256] = samples[i + 512] + common;
00369     }
00370 }
00371 
00372 static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
00373 {
00374     int i;
00375     sample_t common;
00376 
00377     for (i = 0; i < 256; i++) {
00378         common = BIAS (right[i + 256]);
00379         left[i] += common;
00380         right[i] += common;
00381     }
00382 }
00383 
00384 static void mix21toS (sample_t * samples, sample_t bias)
00385 {
00386     int i;
00387     sample_t surround;
00388 
00389     for (i = 0; i < 256; i++) {
00390         surround = samples[i + 512];
00391         samples[i] += BIAS (-surround);
00392         samples[i + 256] += BIAS (surround);
00393     }
00394 }
00395 
00396 static void mix31to2 (sample_t * samples, sample_t bias)
00397 {
00398     int i;
00399     sample_t common;
00400 
00401     for (i = 0; i < 256; i++) {
00402         common = BIAS (samples[i + 256] + samples[i + 768]);
00403         samples[i] += common;
00404         samples[i + 256] = samples[i + 512] + common;
00405     }
00406 }
00407 
00408 static void mix31toS (sample_t * samples, sample_t bias)
00409 {
00410     int i;
00411     sample_t common, surround;
00412 
00413     for (i = 0; i < 256; i++) {
00414         common = BIAS (samples[i + 256]);
00415         surround = samples[i + 768];
00416         samples[i] += common - surround;
00417         samples[i + 256] = samples[i + 512] + common + surround;
00418     }
00419 }
00420 
00421 static void mix22toS (sample_t * samples, sample_t bias)
00422 {
00423     int i;
00424     sample_t surround;
00425 
00426     for (i = 0; i < 256; i++) {
00427         surround = samples[i + 512] + samples[i + 768];
00428         samples[i] += BIAS (-surround);
00429         samples[i + 256] += BIAS (surround);
00430     }
00431 }
00432 
00433 static void mix32to2 (sample_t * samples, sample_t bias)
00434 {
00435     int i;
00436     sample_t common;
00437 
00438     for (i = 0; i < 256; i++) {
00439         common = BIAS (samples[i + 256]);
00440         samples[i] += common + samples[i + 768];
00441         samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
00442     }
00443 }
00444 
00445 static void mix32toS (sample_t * samples, sample_t bias)
00446 {
00447     int i;
00448     sample_t common, surround;
00449 
00450     for (i = 0; i < 256; i++) {
00451         common = BIAS (samples[i + 256]);
00452         surround = samples[i + 768] + samples[i + 1024];
00453         samples[i] += common - surround;
00454         samples[i + 256] = samples[i + 512] + common + surround;
00455     }
00456 }
00457 
00458 static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
00459 {
00460     int i;
00461 
00462     for (i = 0; i < 256; i++)
00463         dest[i] = BIAS (src[i] + src[i + 256]);
00464 }
00465 
00466 static void zero (sample_t * samples)
00467 {
00468     int i;
00469 
00470     for (i = 0; i < 256; i++)
00471         samples[i] = 0;
00472 }
00473 
00474 void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
00475                   level_t clev, level_t slev)
00476 {
00477     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
00478 
00479     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
00480         memcpy (samples, samples + 256, 256 * sizeof (sample_t));
00481         break;
00482 
00483     case CONVERT (A52_CHANNEL, A52_MONO):
00484     case CONVERT (A52_STEREO, A52_MONO):
00485     mix_2to1:
00486         mix2to1 (samples, samples + 256, bias);
00487         break;
00488 
00489     case CONVERT (A52_2F1R, A52_MONO):
00490         if (slev == 0)
00491             goto mix_2to1;
00492     case CONVERT (A52_3F, A52_MONO):
00493     mix_3to1:
00494         mix3to1 (samples, bias);
00495         break;
00496 
00497     case CONVERT (A52_3F1R, A52_MONO):
00498         if (slev == 0)
00499             goto mix_3to1;
00500     case CONVERT (A52_2F2R, A52_MONO):
00501         if (slev == 0)
00502             goto mix_2to1;
00503         mix4to1 (samples, bias);
00504         break;
00505 
00506     case CONVERT (A52_3F2R, A52_MONO):
00507         if (slev == 0)
00508             goto mix_3to1;
00509         mix5to1 (samples, bias);
00510         break;
00511 
00512     case CONVERT (A52_MONO, A52_DOLBY):
00513         memcpy (samples + 256, samples, 256 * sizeof (sample_t));
00514         break;
00515 
00516     case CONVERT (A52_3F, A52_STEREO):
00517     case CONVERT (A52_3F, A52_DOLBY):
00518     mix_3to2:
00519         mix3to2 (samples, bias);
00520         break;
00521 
00522     case CONVERT (A52_2F1R, A52_STEREO):
00523         if (slev == 0)
00524             break;
00525         mix21to2 (samples, samples + 256, bias);
00526         break;
00527 
00528     case CONVERT (A52_2F1R, A52_DOLBY):
00529         mix21toS (samples, bias);
00530         break;
00531 
00532     case CONVERT (A52_3F1R, A52_STEREO):
00533         if (slev == 0)
00534             goto mix_3to2;
00535         mix31to2 (samples, bias);
00536         break;
00537 
00538     case CONVERT (A52_3F1R, A52_DOLBY):
00539         mix31toS (samples, bias);
00540         break;
00541 
00542     case CONVERT (A52_2F2R, A52_STEREO):
00543         if (slev == 0)
00544             break;
00545         mix2to1 (samples, samples + 512, bias);
00546         mix2to1 (samples + 256, samples + 768, bias);
00547         break;
00548 
00549     case CONVERT (A52_2F2R, A52_DOLBY):
00550         mix22toS (samples, bias);
00551         break;
00552 
00553     case CONVERT (A52_3F2R, A52_STEREO):
00554         if (slev == 0)
00555             goto mix_3to2;
00556         mix32to2 (samples, bias);
00557         break;
00558 
00559     case CONVERT (A52_3F2R, A52_DOLBY):
00560         mix32toS (samples, bias);
00561         break;
00562 
00563     case CONVERT (A52_3F1R, A52_3F):
00564         if (slev == 0)
00565             break;
00566         mix21to2 (samples, samples + 512, bias);
00567         break;
00568 
00569     case CONVERT (A52_3F2R, A52_3F):
00570         if (slev == 0)
00571             break;
00572         mix2to1 (samples, samples + 768, bias);
00573         mix2to1 (samples + 512, samples + 1024, bias);
00574         break;
00575 
00576     case CONVERT (A52_3F1R, A52_2F1R):
00577         mix3to2 (samples, bias);
00578         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
00579         break;
00580 
00581     case CONVERT (A52_2F2R, A52_2F1R):
00582         mix2to1 (samples + 512, samples + 768, bias);
00583         break;
00584 
00585     case CONVERT (A52_3F2R, A52_2F1R):
00586         mix3to2 (samples, bias);
00587         move2to1 (samples + 768, samples + 512, bias);
00588         break;
00589 
00590     case CONVERT (A52_3F2R, A52_3F1R):
00591         mix2to1 (samples + 768, samples + 1024, bias);
00592         break;
00593 
00594     case CONVERT (A52_2F1R, A52_2F2R):
00595         memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
00596         break;
00597 
00598     case CONVERT (A52_3F1R, A52_2F2R):
00599         mix3to2 (samples, bias);
00600         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
00601         break;
00602 
00603     case CONVERT (A52_3F2R, A52_2F2R):
00604         mix3to2 (samples, bias);
00605         memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
00606         memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
00607         break;
00608 
00609     case CONVERT (A52_3F1R, A52_3F2R):
00610         memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
00611         break;
00612     }
00613 }
00614 
00615 void a52_upmix (sample_t * samples, int acmod, int output)
00616 {
00617     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
00618 
00619     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
00620         memcpy (samples + 256, samples, 256 * sizeof (sample_t));
00621         break;
00622 
00623     case CONVERT (A52_3F2R, A52_MONO):
00624         zero (samples + 1024);
00625     case CONVERT (A52_3F1R, A52_MONO):
00626     case CONVERT (A52_2F2R, A52_MONO):
00627         zero (samples + 768);
00628     case CONVERT (A52_3F, A52_MONO):
00629     case CONVERT (A52_2F1R, A52_MONO):
00630         zero (samples + 512);
00631     case CONVERT (A52_CHANNEL, A52_MONO):
00632     case CONVERT (A52_STEREO, A52_MONO):
00633         zero (samples + 256);
00634         break;
00635 
00636     case CONVERT (A52_3F2R, A52_STEREO):
00637     case CONVERT (A52_3F2R, A52_DOLBY):
00638         zero (samples + 1024);
00639     case CONVERT (A52_3F1R, A52_STEREO):
00640     case CONVERT (A52_3F1R, A52_DOLBY):
00641         zero (samples + 768);
00642     case CONVERT (A52_3F, A52_STEREO):
00643     case CONVERT (A52_3F, A52_DOLBY):
00644     mix_3to2:
00645         memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
00646         zero (samples + 256);
00647         break;
00648 
00649     case CONVERT (A52_2F2R, A52_STEREO):
00650     case CONVERT (A52_2F2R, A52_DOLBY):
00651         zero (samples + 768);
00652     case CONVERT (A52_2F1R, A52_STEREO):
00653     case CONVERT (A52_2F1R, A52_DOLBY):
00654         zero (samples + 512);
00655         break;
00656 
00657     case CONVERT (A52_3F2R, A52_3F):
00658         zero (samples + 1024);
00659     case CONVERT (A52_3F1R, A52_3F):
00660     case CONVERT (A52_2F2R, A52_2F1R):
00661         zero (samples + 768);
00662         break;
00663 
00664     case CONVERT (A52_3F2R, A52_3F1R):
00665         zero (samples + 1024);
00666         break;
00667 
00668     case CONVERT (A52_3F2R, A52_2F1R):
00669         zero (samples + 1024);
00670     case CONVERT (A52_3F1R, A52_2F1R):
00671     mix_31to21:
00672         memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
00673         goto mix_3to2;
00674 
00675     case CONVERT (A52_3F2R, A52_2F2R):
00676         memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
00677         goto mix_31to21;
00678     }
00679 }