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

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

多媒体编程

开发平台：

Visual C++

dts_downmix.c：源码内容
  1. /*
  2.  * downmix.c
  3.  * Copyright (C) 2004 Gildas Bazin <gbazin@videolan.org>
  4.  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
  5.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  6.  *
  7.  * This file is part of dtsdec, a free DTS Coherent Acoustics stream decoder.
  8.  * See http://www.videolan.org/dtsdec.html for updates.
  9.  *
  10.  * dtsdec is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * dtsdec is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23.  */
  25. #include "config.h"
  27. #include <string.h>
  28. #include <inttypes.h>
  30. #include "dts.h"
  31. #include "dts_internal.h"
  33. #define CONVERT(acmod,output) (((output) << DTS_CHANNEL_BITS) + (acmod))
  35. int dts_downmix_init (int input, int flags, level_t * level,
  36.       level_t clev, level_t slev)
  37. {
  38.     static uint8_t table[11][10] = {
  39.         /* DTS_MONO */
  40.         {DTS_MONO,      DTS_MONO,       DTS_MONO,       DTS_MONO,
  41.          DTS_MONO,      DTS_MONO,       DTS_MONO,       DTS_MONO,
  42.          DTS_MONO,      DTS_MONO},
  43.         /* DTS_CHANNEL */
  44.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  45.          DTS_STEREO,    DTS_STEREO,     DTS_STEREO,     DTS_STEREO,
  46.          DTS_STEREO,    DTS_STEREO},
  47.         /* DTS_STEREO */
  48.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  49.          DTS_STEREO,    DTS_STEREO,     DTS_STEREO,     DTS_STEREO,
  50.          DTS_STEREO,    DTS_STEREO},
  51.         /* DTS_STEREO_SUMDIFF */
  52.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  53.          DTS_STEREO,    DTS_STEREO,     DTS_STEREO,     DTS_STEREO,
  54.          DTS_STEREO,    DTS_STEREO},
  55.         /* DTS_STEREO_TOTAL */
  56.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  57.          DTS_STEREO,    DTS_STEREO,     DTS_STEREO,     DTS_STEREO,
  58.          DTS_STEREO,    DTS_STEREO},
  59.         /* DTS_3F */
  60.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  61.          DTS_STEREO,    DTS_3F,         DTS_3F,         DTS_3F,
  62.          DTS_3F,        DTS_3F},
  63.         /* DTS_2F1R */
  64.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  65.          DTS_STEREO,    DTS_2F1R,       DTS_2F1R,       DTS_2F1R,
  66.          DTS_2F1R,      DTS_2F1R},
  67.         /* DTS_3F1R */
  68.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  69.          DTS_STEREO,    DTS_3F,         DTS_3F1R,       DTS_3F1R,
  70.          DTS_3F1R,      DTS_3F1R},
  71.         /* DTS_2F2R */
  72.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  73.          DTS_STEREO,    DTS_STEREO,     DTS_2F2R,       DTS_2F2R,
  74.          DTS_2F2R,      DTS_2F2R},
  75.         /* DTS_3F2R */
  76.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  77.          DTS_STEREO,    DTS_3F,         DTS_3F2R,       DTS_3F2R,
  78.          DTS_3F2R,      DTS_3F2R},
  79.         /* DTS_4F2R */
  80.         {DTS_MONO,      DTS_CHANNEL,    DTS_STEREO,     DTS_STEREO,
  81.          DTS_STEREO,    DTS_4F2R,       DTS_4F2R,       DTS_4F2R,
  82.          DTS_4F2R,      DTS_4F2R},
  83.     };
  84.     int output;
  86.     output = flags & DTS_CHANNEL_MASK;
  88.     if (output > DTS_CHANNEL_MAX)
  89. return -1;
  91.     output = table[output][input];
  93.     if (output == DTS_STEREO &&
  94. (input == DTS_DOLBY || (input == DTS_3F && clev == LEVEL (LEVEL_3DB))))
  95. output = DTS_DOLBY;
  97.     if (flags & DTS_ADJUST_LEVEL) {
  98. level_t adjust;
  100. switch (CONVERT (input & 7, output)) {
  102. case CONVERT (DTS_3F, DTS_MONO):
  103.     adjust = DIV (LEVEL_3DB, LEVEL (1) + clev);
  104.     break;
  106. case CONVERT (DTS_STEREO, DTS_MONO):
  107. case CONVERT (DTS_2F2R, DTS_2F1R):
  108. case CONVERT (DTS_3F2R, DTS_3F1R):
  109. level_3db:
  110.     adjust = LEVEL (LEVEL_3DB);
  111.     break;
  113. case CONVERT (DTS_3F2R, DTS_2F1R):
  114.     if (clev < LEVEL (LEVEL_PLUS3DB - 1))
  115. goto level_3db;
  116.     /* break thru */
  117. case CONVERT (DTS_3F, DTS_STEREO):
  118. case CONVERT (DTS_3F1R, DTS_2F1R):
  119. case CONVERT (DTS_3F1R, DTS_2F2R):
  120. case CONVERT (DTS_3F2R, DTS_2F2R):
  121.     adjust = DIV (1, LEVEL (1) + clev);
  122.     break;
  124. case CONVERT (DTS_2F1R, DTS_MONO):
  125.     adjust = DIV (LEVEL_PLUS3DB, LEVEL (2) + slev);
  126.     break;
  128. case CONVERT (DTS_2F1R, DTS_STEREO):
  129. case CONVERT (DTS_3F1R, DTS_3F):
  130.     adjust = DIV (1, LEVEL (1) + MUL_C (slev, LEVEL_3DB));
  131.     break;
  133. case CONVERT (DTS_3F1R, DTS_MONO):
  134.     adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + MUL_C (slev, 0.5));
  135.     break;
  137. case CONVERT (DTS_3F1R, DTS_STEREO):
  138.     adjust = DIV (1, LEVEL (1) + clev + MUL_C (slev, LEVEL_3DB));
  139.     break;
  141. case CONVERT (DTS_2F2R, DTS_MONO):
  142.     adjust = DIV (LEVEL_3DB, LEVEL (1) + slev);
  143.     break;
  145. case CONVERT (DTS_2F2R, DTS_STEREO):
  146. case CONVERT (DTS_3F2R, DTS_3F):
  147.     adjust = DIV (1, LEVEL (1) + slev);
  148.     break;
  150. case CONVERT (DTS_3F2R, DTS_MONO):
  151.     adjust = DIV (LEVEL_3DB, LEVEL (1) + clev + slev);
  152.     break;
  154. case CONVERT (DTS_3F2R, DTS_STEREO):
  155.     adjust = DIV (1, LEVEL (1) + clev + slev);
  156.     break;
  158. case CONVERT (DTS_MONO, DTS_DOLBY):
  159.     adjust = LEVEL (LEVEL_PLUS3DB);
  160.     break;
  162. case CONVERT (DTS_3F, DTS_DOLBY):
  163. case CONVERT (DTS_2F1R, DTS_DOLBY):
  164.     adjust = LEVEL (1 / (1 + LEVEL_3DB));
  165.     break;
  167. case CONVERT (DTS_3F1R, DTS_DOLBY):
  168. case CONVERT (DTS_2F2R, DTS_DOLBY):
  169.     adjust = LEVEL (1 / (1 + 2 * LEVEL_3DB));
  170.     break;
  172. case CONVERT (DTS_3F2R, DTS_DOLBY):
  173.     adjust = LEVEL (1 / (1 + 3 * LEVEL_3DB));
  174.     break;
  176. default:
  177.     return output;
  178. }
  180. *level = MUL_L (*level, adjust);
  181.     }
  183.     return output;
  184. }
  186. int dts_downmix_coeff (level_t * coeff, int acmod, int output, level_t level,
  187.        level_t clev, level_t slev)
  188. {
  189.     level_t level_3db;
  191.     level_3db = MUL_C (level, LEVEL_3DB);
  193.     switch (CONVERT (acmod, output & DTS_CHANNEL_MASK)) {
  195.     case CONVERT (DTS_CHANNEL, DTS_CHANNEL):
  196.     case CONVERT (DTS_MONO, DTS_MONO):
  197.     case CONVERT (DTS_STEREO, DTS_STEREO):
  198.     case CONVERT (DTS_3F, DTS_3F):
  199.     case CONVERT (DTS_2F1R, DTS_2F1R):
  200.     case CONVERT (DTS_3F1R, DTS_3F1R):
  201.     case CONVERT (DTS_2F2R, DTS_2F2R):
  202.     case CONVERT (DTS_3F2R, DTS_3F2R):
  203.     case CONVERT (DTS_STEREO, DTS_DOLBY):
  204. coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
  205. return 0;
  207.     case CONVERT (DTS_CHANNEL, DTS_MONO):
  208. coeff[0] = coeff[1] = MUL_C (level, LEVEL_6DB);
  209. return 3;
  211.     case CONVERT (DTS_STEREO, DTS_MONO):
  212. coeff[0] = coeff[1] = level_3db;
  213. return 3;
  215.     case CONVERT (DTS_3F, DTS_MONO):
  216. coeff[0] = coeff[2] = level_3db;
  217. coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
  218. return 7;
  220.     case CONVERT (DTS_2F1R, DTS_MONO):
  221. coeff[0] = coeff[1] = level_3db;
  222. coeff[2] = MUL_L (level_3db, slev);
  223. return 7;
  225.     case CONVERT (DTS_2F2R, DTS_MONO):
  226. coeff[0] = coeff[1] = level_3db;
  227. coeff[2] = coeff[3] = MUL_L (level_3db, slev);
  228. return 15;
  230.     case CONVERT (DTS_3F1R, DTS_MONO):
  231. coeff[0] = coeff[2] = level_3db;
  232. coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
  233. coeff[3] = MUL_L (level_3db, slev);
  234. return 15;
  236.     case CONVERT (DTS_3F2R, DTS_MONO):
  237. coeff[0] = coeff[2] = level_3db;
  238. coeff[1] = MUL_C (MUL_L (level_3db, clev), LEVEL_PLUS6DB);
  239. coeff[3] = coeff[4] = MUL_L (level_3db, slev);
  240. return 31;
  242.     case CONVERT (DTS_MONO, DTS_DOLBY):
  243. coeff[0] = level_3db;
  244. return 0;
  246.     case CONVERT (DTS_3F, DTS_DOLBY):
  247. coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
  248. coeff[1] = level_3db;
  249. return 7;
  251.     case CONVERT (DTS_3F, DTS_STEREO):
  252.     case CONVERT (DTS_3F1R, DTS_2F1R):
  253.     case CONVERT (DTS_3F2R, DTS_2F2R):
  254. coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
  255. coeff[1] = MUL_L (level, clev);
  256. return 7;
  258.     case CONVERT (DTS_2F1R, DTS_DOLBY):
  259. coeff[0] = coeff[1] = level;
  260. coeff[2] = level_3db;
  261. return 7;
  263.     case CONVERT (DTS_2F1R, DTS_STEREO):
  264. coeff[0] = coeff[1] = level;
  265. coeff[2] = MUL_L (level_3db, slev);
  266. return 7;
  268.     case CONVERT (DTS_3F1R, DTS_DOLBY):
  269. coeff[0] = coeff[2] = level;
  270. coeff[1] = coeff[3] = level_3db;
  271. return 15;
  273.     case CONVERT (DTS_3F1R, DTS_STEREO):
  274. coeff[0] = coeff[2] = level;
  275. coeff[1] = MUL_L (level, clev);
  276. coeff[3] = MUL_L (level_3db, slev);
  277. return 15;
  279.     case CONVERT (DTS_2F2R, DTS_DOLBY):
  280. coeff[0] = coeff[1] = level;
  281. coeff[2] = coeff[3] = level_3db;
  282. return 15;
  284.     case CONVERT (DTS_2F2R, DTS_STEREO):
  285. coeff[0] = coeff[1] = level;
  286. coeff[2] = coeff[3] = MUL_L (level, slev);
  287. return 15;
  289.     case CONVERT (DTS_3F2R, DTS_DOLBY):
  290. coeff[0] = coeff[2] = level;
  291. coeff[1] = coeff[3] = coeff[4] = level_3db;
  292. return 31;
  294.     case CONVERT (DTS_3F2R, DTS_2F1R):
  295. coeff[0] = coeff[2] = level;
  296. coeff[1] = MUL_L (level, clev);
  297. coeff[3] = coeff[4] = level_3db;
  298. return 31;
  300.     case CONVERT (DTS_3F2R, DTS_STEREO):
  301. coeff[0] = coeff[2] = level;
  302. coeff[1] = MUL_L (level, clev);
  303. coeff[3] = coeff[4] = MUL_L (level, slev);
  304. return 31;
  306.     case CONVERT (DTS_3F1R, DTS_3F):
  307. coeff[0] = coeff[1] = coeff[2] = level;
  308. coeff[3] = MUL_L (level_3db, slev);
  309. return 13;
  311.     case CONVERT (DTS_3F2R, DTS_3F):
  312. coeff[0] = coeff[1] = coeff[2] = level;
  313. coeff[3] = coeff[4] = MUL_L (level, slev);
  314. return 29;
  316.     case CONVERT (DTS_2F2R, DTS_2F1R):
  317. coeff[0] = coeff[1] = level;
  318. coeff[2] = coeff[3] = level_3db;
  319. return 12;
  321.     case CONVERT (DTS_3F2R, DTS_3F1R):
  322. coeff[0] = coeff[1] = coeff[2] = level;
  323. coeff[3] = coeff[4] = level_3db;
  324. return 24;
  326.     case CONVERT (DTS_2F1R, DTS_2F2R):
  327. coeff[0] = coeff[1] = level;
  328. coeff[2] = level_3db;
  329. return 0;
  331.     case CONVERT (DTS_3F1R, DTS_2F2R):
  332. coeff[0] = coeff[2] = level;
  333. coeff[1] = MUL_L (level, clev);
  334. coeff[3] = level_3db;
  335. return 7;
  337.     case CONVERT (DTS_3F1R, DTS_3F2R):
  338. coeff[0] = coeff[1] = coeff[2] = level;
  339. coeff[3] = level_3db;
  340. return 0;
  341.     }
  343.     return -1; /* NOTREACHED */
  344. }
  346. static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
  347. {
  348.     int i;
  350.     for (i = 0; i < 256; i++)
  351. dest[i] += BIAS (src[i]);
  352. }
  354. static void mix3to1 (sample_t * samples, sample_t bias)
  355. {
  356.     int i;
  358.     for (i = 0; i < 256; i++)
  359. samples[i] += BIAS (samples[i + 256] + samples[i + 512]);
  360. }
  362. static void mix4to1 (sample_t * samples, sample_t bias)
  363. {
  364.     int i;
  366.     for (i = 0; i < 256; i++)
  367. samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
  368.     samples[i + 768]);
  369. }
  371. static void mix5to1 (sample_t * samples, sample_t bias)
  372. {
  373.     int i;
  375.     for (i = 0; i < 256; i++)
  376. samples[i] += BIAS (samples[i + 256] + samples[i + 512] +
  377.     samples[i + 768] + samples[i + 1024]);
  378. }
  380. static void mix3to2 (sample_t * samples, sample_t bias)
  381. {
  382.     int i;
  383.     sample_t common;
  385.     for (i = 0; i < 256; i++) {
  386. common = BIAS (samples[i]);
  387. samples[i] = samples[i + 256] + common;
  388. samples[i + 256] = samples[i + 512] + common;
  389.     }
  390. }
  392. static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
  393. {
  394.     int i;
  395.     sample_t common;
  397.     for (i = 0; i < 256; i++) {
  398. common = BIAS (right[i + 256]);
  399. left[i] += common;
  400. right[i] += common;
  401.     }
  402. }
  404. static void mix21toS (sample_t * samples, sample_t bias)
  405. {
  406.     int i;
  407.     sample_t surround;
  409.     for (i = 0; i < 256; i++) {
  410. surround = samples[i + 512];
  411. samples[i] += BIAS (-surround);
  412. samples[i + 256] += BIAS (surround);
  413.     }
  414. }
  416. static void mix31to2 (sample_t * samples, sample_t bias)
  417. {
  418.     int i;
  419.     sample_t common;
  421.     for (i = 0; i < 256; i++) {
  422. common = BIAS (samples[i] + samples[i + 768]);
  423. samples[i] = samples[i + 256] + common;
  424. samples[i + 256] = samples[i + 512] + common;
  425.     }
  426. }
  428. static void mix31toS (sample_t * samples, sample_t bias)
  429. {
  430.     int i;
  431.     sample_t common, surround;
  433.     for (i = 0; i < 256; i++) {
  434. common = BIAS (samples[i]);
  435. surround = samples[i + 768];
  436. samples[i] = samples[i + 256] + common - surround;
  437. samples[i + 256] = samples[i + 512] + common + surround;
  438.     }
  439. }
  441. static void mix22toS (sample_t * samples, sample_t bias)
  442. {
  443.     int i;
  444.     sample_t surround;
  446.     for (i = 0; i < 256; i++) {
  447. surround = samples[i + 512] + samples[i + 768];
  448. samples[i] += BIAS (-surround);
  449. samples[i + 256] += BIAS (surround);
  450.     }
  451. }
  453. static void mix32to2 (sample_t * samples, sample_t bias)
  454. {
  455.     int i;
  456.     sample_t common;
  458.     for (i = 0; i < 256; i++) {
  459. common = BIAS (samples[i]);
  460. samples[i] = common + samples[i + 256] + samples[i + 768];
  461. samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
  462.     }
  463. }
  465. static void mix32toS (sample_t * samples, sample_t bias)
  466. {
  467.     int i;
  468.     sample_t common, surround;
  470.     for (i = 0; i < 256; i++) {
  471. common = BIAS (samples[i]);
  472. surround = samples[i + 768] + samples[i + 1024];
  473. samples[i] = samples[i + 256] + common - surround;
  474. samples[i + 256] = samples[i + 512] + common + surround;
  475.     }
  476. }
  478. static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
  479. {
  480.     int i;
  482.     for (i = 0; i < 256; i++)
  483. dest[i] = BIAS (src[i] + src[i + 256]);
  484. }
  486. static void zero (sample_t * samples)
  487. {
  488.     int i;
  490.     for (i = 0; i < 256; i++)
  491. samples[i] = 0;
  492. }
  494. void dts_downmix (sample_t * samples, int acmod, int output, sample_t bias,
  495.   level_t clev, level_t slev)
  496. {
  497.     switch (CONVERT (acmod, output & DTS_CHANNEL_MASK)) {
  499.     case CONVERT (DTS_CHANNEL, DTS_MONO):
  500.     case CONVERT (DTS_STEREO, DTS_MONO):
  501.     mix_2to1:
  502. mix2to1 (samples, samples + 256, bias);
  503. break;
  505.     case CONVERT (DTS_2F1R, DTS_MONO):
  506. if (slev == 0)
  507.     goto mix_2to1;
  508.     case CONVERT (DTS_3F, DTS_MONO):
  509.     mix_3to1:
  510. mix3to1 (samples, bias);
  511. break;
  513.     case CONVERT (DTS_3F1R, DTS_MONO):
  514. if (slev == 0)
  515.     goto mix_3to1;
  516.     case CONVERT (DTS_2F2R, DTS_MONO):
  517. if (slev == 0)
  518.     goto mix_2to1;
  519. mix4to1 (samples, bias);
  520. break;
  522.     case CONVERT (DTS_3F2R, DTS_MONO):
  523. if (slev == 0)
  524.     goto mix_3to1;
  525. mix5to1 (samples, bias);
  526. break;
  528.     case CONVERT (DTS_MONO, DTS_DOLBY):
  529. memcpy (samples + 256, samples, 256 * sizeof (sample_t));
  530. break;
  532.     case CONVERT (DTS_3F, DTS_STEREO):
  533.     case CONVERT (DTS_3F, DTS_DOLBY):
  534.     mix_3to2:
  535. mix3to2 (samples, bias);
  536. break;
  538.     case CONVERT (DTS_2F1R, DTS_STEREO):
  539. if (slev == 0)
  540.     break;
  541. mix21to2 (samples, samples + 256, bias);
  542. break;
  544.     case CONVERT (DTS_2F1R, DTS_DOLBY):
  545. mix21toS (samples, bias);
  546. break;
  548.     case CONVERT (DTS_3F1R, DTS_STEREO):
  549. if (slev == 0)
  550.     goto mix_3to2;
  551. mix31to2 (samples, bias);
  552. break;
  554.     case CONVERT (DTS_3F1R, DTS_DOLBY):
  555. mix31toS (samples, bias);
  556. break;
  558.     case CONVERT (DTS_2F2R, DTS_STEREO):
  559. if (slev == 0)
  560.     break;
  561. mix2to1 (samples, samples + 512, bias);
  562. mix2to1 (samples + 256, samples + 768, bias);
  563. break;
  565.     case CONVERT (DTS_2F2R, DTS_DOLBY):
  566. mix22toS (samples, bias);
  567. break;
  569.     case CONVERT (DTS_3F2R, DTS_STEREO):
  570. if (slev == 0)
  571.     goto mix_3to2;
  572. mix32to2 (samples, bias);
  573. break;
  575.     case CONVERT (DTS_3F2R, DTS_DOLBY):
  576. mix32toS (samples, bias);
  577. break;
  579.     case CONVERT (DTS_3F1R, DTS_3F):
  580. if (slev == 0)
  581.     break;
  582. mix21to2 (samples, samples + 512, bias);
  583. break;
  585.     case CONVERT (DTS_3F2R, DTS_3F):
  586. if (slev == 0)
  587.     break;
  588. mix2to1 (samples, samples + 768, bias);
  589. mix2to1 (samples + 512, samples + 1024, bias);
  590. break;
  592.     case CONVERT (DTS_3F1R, DTS_2F1R):
  593. mix3to2 (samples, bias);
  594. memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  595. break;
  597.     case CONVERT (DTS_2F2R, DTS_2F1R):
  598. mix2to1 (samples + 512, samples + 768, bias);
  599. break;
  601.     case CONVERT (DTS_3F2R, DTS_2F1R):
  602. mix3to2 (samples, bias);
  603. move2to1 (samples + 768, samples + 512, bias);
  604. break;
  606.     case CONVERT (DTS_3F2R, DTS_3F1R):
  607. mix2to1 (samples + 768, samples + 1024, bias);
  608. break;
  610.     case CONVERT (DTS_2F1R, DTS_2F2R):
  611. memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
  612. break;
  614.     case CONVERT (DTS_3F1R, DTS_2F2R):
  615. mix3to2 (samples, bias);
  616. memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  617. break;
  619.     case CONVERT (DTS_3F2R, DTS_2F2R):
  620. mix3to2 (samples, bias);
  621. memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  622. memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
  623. break;
  625.     case CONVERT (DTS_3F1R, DTS_3F2R):
  626. memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
  627. break;
  628.     }
  629. }
  631. void dts_upmix (sample_t * samples, int acmod, int output)
  632. {
  633.     switch (CONVERT (acmod, output & DTS_CHANNEL_MASK)) {
  635.     case CONVERT (DTS_3F2R, DTS_MONO):
  636. zero (samples + 1024);
  637.     case CONVERT (DTS_3F1R, DTS_MONO):
  638.     case CONVERT (DTS_2F2R, DTS_MONO):
  639. zero (samples + 768);
  640.     case CONVERT (DTS_3F, DTS_MONO):
  641.     case CONVERT (DTS_2F1R, DTS_MONO):
  642. zero (samples + 512);
  643.     case CONVERT (DTS_CHANNEL, DTS_MONO):
  644.     case CONVERT (DTS_STEREO, DTS_MONO):
  645. zero (samples + 256);
  646. break;
  648.     case CONVERT (DTS_3F2R, DTS_STEREO):
  649.     case CONVERT (DTS_3F2R, DTS_DOLBY):
  650. zero (samples + 1024);
  651.     case CONVERT (DTS_3F1R, DTS_STEREO):
  652.     case CONVERT (DTS_3F1R, DTS_DOLBY):
  653. zero (samples + 768);
  654.     case CONVERT (DTS_3F, DTS_STEREO):
  655.     case CONVERT (DTS_3F, DTS_DOLBY):
  656.     mix_3to2:
  657. memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
  658. zero (samples + 256);
  659. break;
  661.     case CONVERT (DTS_2F2R, DTS_STEREO):
  662.     case CONVERT (DTS_2F2R, DTS_DOLBY):
  663. zero (samples + 768);
  664.     case CONVERT (DTS_2F1R, DTS_STEREO):
  665.     case CONVERT (DTS_2F1R, DTS_DOLBY):
  666. zero (samples + 512);
  667. break;
  669.     case CONVERT (DTS_3F2R, DTS_3F):
  670. zero (samples + 1024);
  671.     case CONVERT (DTS_3F1R, DTS_3F):
  672.     case CONVERT (DTS_2F2R, DTS_2F1R):
  673. zero (samples + 768);
  674. break;
  676.     case CONVERT (DTS_3F2R, DTS_3F1R):
  677. zero (samples + 1024);
  678. break;
  680.     case CONVERT (DTS_3F2R, DTS_2F1R):
  681. zero (samples + 1024);
  682.     case CONVERT (DTS_3F1R, DTS_2F1R):
  683.     mix_31to21:
  684. memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
  685. goto mix_3to2;
  687.     case CONVERT (DTS_3F2R, DTS_2F2R):
  688. memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
  689. goto mix_31to21;
  690.     }
  691. }