开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
downmix.c
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

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.  */
  24. #include "config.h"
  26. #include <string.h>
  27. #include <inttypes.h>
  29. #include "a52.h"
  30. #include "a52_internal.h"
  32. #define CONVERT(acmod,output) (((output) << 3) + (acmod))
  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;
  63.     output = flags & A52_CHANNEL_MASK;
  64.     if (output > A52_DOLBY)
  65. return -1;
  67.     output = table[output][input & 7];
  69.     if ((output == A52_STEREO) &&
  70. ((input == A52_DOLBY) || ((input == A52_3F) && (clev == LEVEL_3DB))))
  71. output = A52_DOLBY;
  73.     if (flags & A52_ADJUST_LEVEL)
  74. switch (CONVERT (input & 7, output)) {
  76. case CONVERT (A52_3F, A52_MONO):
  77.     *level *= LEVEL_3DB / (1 + clev);
  78.     break;
  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;
  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;
  98. case CONVERT (A52_2F1R, A52_MONO):
  99.     *level *= LEVEL_PLUS3DB / (2 + slev);
  100.     break;
  102. case CONVERT (A52_2F1R, A52_STEREO):
  103. case CONVERT (A52_3F1R, A52_3F):
  104.     *level /= 1 + slev * LEVEL_3DB;
  105.     break;
  107. case CONVERT (A52_3F1R, A52_MONO):
  108.     *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
  109.     break;
  111. case CONVERT (A52_3F1R, A52_STEREO):
  112.     *level /= 1 + clev + slev * LEVEL_3DB;
  113.     break;
  115. case CONVERT (A52_2F2R, A52_MONO):
  116.     *level *= LEVEL_3DB / (1 + slev);
  117.     break;
  119. case CONVERT (A52_2F2R, A52_STEREO):
  120. case CONVERT (A52_3F2R, A52_3F):
  121.     *level /= 1 + slev;
  122.     break;
  124. case CONVERT (A52_3F2R, A52_MONO):
  125.     *level *= LEVEL_3DB / (1 + clev + slev);
  126.     break;
  128. case CONVERT (A52_3F2R, A52_STEREO):
  129.     *level /= 1 + clev + slev;
  130.     break;
  132. case CONVERT (A52_MONO, A52_DOLBY):
  133.     *level *= LEVEL_PLUS3DB;
  134.     break;
  136. case CONVERT (A52_3F, A52_DOLBY):
  137. case CONVERT (A52_2F1R, A52_DOLBY):
  138.     *level *= 1 / (1 + LEVEL_3DB);
  139.     break;
  141. case CONVERT (A52_3F1R, A52_DOLBY):
  142. case CONVERT (A52_2F2R, A52_DOLBY):
  143.     *level *= 1 / (1 + 2 * LEVEL_3DB);
  144.     break;
  146. case CONVERT (A52_3F2R, A52_DOLBY):
  147.     *level *= 1 / (1 + 3 * LEVEL_3DB);
  148.     break;
  149. }
  151.     return output;
  152. }
  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)) {
  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;
  171.     case CONVERT (A52_CHANNEL, A52_MONO):
  172. coeff[0] = coeff[1] = level * LEVEL_6DB;
  173. return 3;
  175.     case CONVERT (A52_STEREO, A52_MONO):
  176. coeff[0] = coeff[1] = level * LEVEL_3DB;
  177. return 3;
  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;
  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;
  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;
  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;
  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;
  206.     case CONVERT (A52_MONO, A52_DOLBY):
  207. coeff[0] = level * LEVEL_3DB;
  208. return 0;
  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;
  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;
  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;
  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;
  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;
  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;
  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;
  262.     case CONVERT (A52_2F2R, A52_2F1R):
  263. coeff[0] = coeff[1] = level;
  264. coeff[2] = coeff[3] = level * LEVEL_3DB;
  265. return 12;
  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;
  272.     case CONVERT (A52_2F1R, A52_2F2R):
  273. coeff[0] = coeff[1] = level;
  274. coeff[2] = level * LEVEL_3DB;
  275. return 0;
  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;
  283.     case CONVERT (A52_3F1R, A52_3F2R):
  284. coeff[0] = coeff[1] = coeff[2] = level;
  285. coeff[3] = level * LEVEL_3DB;
  286. return 0;
  288.     case CONVERT (A52_CHANNEL, A52_CHANNEL1):
  289. coeff[0] = level;
  290. coeff[1] = 0;
  291. return 0;
  293.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  294. coeff[0] = 0;
  295. coeff[1] = level;
  296. return 0;
  297.     }
  299.     return -1; /* NOTREACHED */
  300. }
  302. static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
  303. {
  304.     int i;
  306.     for (i = 0; i < 256; i++)
  307. dest[i] += src[i] + bias;
  308. }
  310. static void mix3to1 (sample_t * samples, sample_t bias)
  311. {
  312.     int i;
  314.     for (i = 0; i < 256; i++)
  315. samples[i] += samples[i + 256] + samples[i + 512] + bias;
  316. }
  318. static void mix4to1 (sample_t * samples, sample_t bias)
  319. {
  320.     int i;
  322.     for (i = 0; i < 256; i++)
  323. samples[i] += (samples[i + 256] + samples[i + 512] +
  324.        samples[i + 768] + bias);
  325. }
  327. static void mix5to1 (sample_t * samples, sample_t bias)
  328. {
  329.     int i;
  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. }
  336. static void mix3to2 (sample_t * samples, sample_t bias)
  337. {
  338.     int i;
  339.     sample_t common;
  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. }
  348. static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
  349. {
  350.     int i;
  351.     sample_t common;
  353.     for (i = 0; i < 256; i++) {
  354. common = right[i + 256] + bias;
  355. left[i] += common;
  356. right[i] += common;
  357.     }
  358. }
  360. static void mix21toS (sample_t * samples, sample_t bias)
  361. {
  362.     int i;
  363.     sample_t surround;
  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. }
  372. static void mix31to2 (sample_t * samples, sample_t bias)
  373. {
  374.     int i;
  375.     sample_t common;
  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. }
  384. static void mix31toS (sample_t * samples, sample_t bias)
  385. {
  386.     int i;
  387.     sample_t common, surround;
  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. }
  397. static void mix22toS (sample_t * samples, sample_t bias)
  398. {
  399.     int i;
  400.     sample_t surround;
  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. }
  409. static void mix32to2 (sample_t * samples, sample_t bias)
  410. {
  411.     int i;
  412.     sample_t common;
  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. }
  421. static void mix32toS (sample_t * samples, sample_t bias)
  422. {
  423.     int i;
  424.     sample_t common, surround;
  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. }
  434. static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
  435. {
  436.     int i;
  438.     for (i = 0; i < 256; i++)
  439. dest[i] = src[i] + src[i + 256] + bias;
  440. }
  442. static void zero (sample_t * samples)
  443. {
  444.     int i;
  446.     for (i = 0; i < 256; i++)
  447. samples[i] = 0;
  448. }
  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)) {
  455.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  456. memcpy (samples, samples + 256, 256 * sizeof (sample_t));
  457. break;
  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;
  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;
  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;
  482.     case CONVERT (A52_3F2R, A52_MONO):
  483. if (slev == 0)
  484.     goto mix_3to1;
  485. mix5to1 (samples, bias);
  486. break;
  488.     case CONVERT (A52_MONO, A52_DOLBY):
  489. memcpy (samples + 256, samples, 256 * sizeof (sample_t));
  490. break;
  492.     case CONVERT (A52_3F, A52_STEREO):
  493.     case CONVERT (A52_3F, A52_DOLBY):
  494.     mix_3to2:
  495. mix3to2 (samples, bias);
  496. break;
  498.     case CONVERT (A52_2F1R, A52_STEREO):
  499. if (slev == 0)
  500.     break;
  501. mix21to2 (samples, samples + 256, bias);
  502. break;
  504.     case CONVERT (A52_2F1R, A52_DOLBY):
  505. mix21toS (samples, bias);
  506. break;
  508.     case CONVERT (A52_3F1R, A52_STEREO):
  509. if (slev == 0)
  510.     goto mix_3to2;
  511. mix31to2 (samples, bias);
  512. break;
  514.     case CONVERT (A52_3F1R, A52_DOLBY):
  515. mix31toS (samples, bias);
  516. break;
  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;
  525.     case CONVERT (A52_2F2R, A52_DOLBY):
  526. mix22toS (samples, bias);
  527. break;
  529.     case CONVERT (A52_3F2R, A52_STEREO):
  530. if (slev == 0)
  531.     goto mix_3to2;
  532. mix32to2 (samples, bias);
  533. break;
  535.     case CONVERT (A52_3F2R, A52_DOLBY):
  536. mix32toS (samples, bias);
  537. break;
  539.     case CONVERT (A52_3F1R, A52_3F):
  540. if (slev == 0)
  541.     break;
  542. mix21to2 (samples, samples + 512, bias);
  543. break;
  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;
  552.     case CONVERT (A52_3F1R, A52_2F1R):
  553. mix3to2 (samples, bias);
  554. memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  555. break;
  557.     case CONVERT (A52_2F2R, A52_2F1R):
  558. mix2to1 (samples + 512, samples + 768, bias);
  559. break;
  561.     case CONVERT (A52_3F2R, A52_2F1R):
  562. mix3to2 (samples, bias);
  563. move2to1 (samples + 768, samples + 512, bias);
  564. break;
  566.     case CONVERT (A52_3F2R, A52_3F1R):
  567. mix2to1 (samples + 768, samples + 1024, bias);
  568. break;
  570.     case CONVERT (A52_2F1R, A52_2F2R):
  571. memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
  572. break;
  574.     case CONVERT (A52_3F1R, A52_2F2R):
  575. mix3to2 (samples, bias);
  576. memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  577. break;
  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;
  585.     case CONVERT (A52_3F1R, A52_3F2R):
  586. memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t));
  587. break;
  588.     }
  589. }
  591. void a52_upmix (sample_t * samples, int acmod, int output)
  592. {
  593.     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
  595.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  596. memcpy (samples + 256, samples, 256 * sizeof (sample_t));
  597. break;
  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;
  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;
  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;
  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;
  640.     case CONVERT (A52_3F2R, A52_3F1R):
  641. zero (samples + 1024);
  642. break;
  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;
  651.     case CONVERT (A52_3F2R, A52_2F2R):
  652. memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
  653. goto mix_31to21;
  654.     }
  655. }