You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1428 lines
51KB

  1. /*
  2. * DCA compatible decoder
  3. * Copyright (C) 2004 Gildas Bazin
  4. * Copyright (C) 2004 Benjamin Zores
  5. * Copyright (C) 2006 Benjamin Larsson
  6. * Copyright (C) 2007 Konstantin Shishkov
  7. *
  8. * This file is part of Libav.
  9. *
  10. * Libav is free software; you can redistribute it and/or
  11. * modify it under the terms of the GNU Lesser General Public
  12. * License as published by the Free Software Foundation; either
  13. * version 2.1 of the License, or (at your option) any later version.
  14. *
  15. * Libav 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 GNU
  18. * Lesser General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU Lesser General Public
  21. * License along with Libav; if not, write to the Free Software
  22. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23. */
  24. #include <math.h>
  25. #include <stddef.h>
  26. #include <stdio.h>
  27. #include "libavutil/channel_layout.h"
  28. #include "libavutil/common.h"
  29. #include "libavutil/float_dsp.h"
  30. #include "libavutil/internal.h"
  31. #include "libavutil/intreadwrite.h"
  32. #include "libavutil/mathematics.h"
  33. #include "libavutil/opt.h"
  34. #include "libavutil/samplefmt.h"
  35. #include "avcodec.h"
  36. #include "dca.h"
  37. #include "dcadata.h"
  38. #include "dcadsp.h"
  39. #include "dcahuff.h"
  40. #include "fft.h"
  41. #include "fmtconvert.h"
  42. #include "get_bits.h"
  43. #include "internal.h"
  44. #include "mathops.h"
  45. #include "put_bits.h"
  46. #include "synth_filter.h"
  47. #if ARCH_ARM
  48. # include "arm/dca.h"
  49. #endif
  50. enum DCAMode {
  51. DCA_MONO = 0,
  52. DCA_CHANNEL,
  53. DCA_STEREO,
  54. DCA_STEREO_SUMDIFF,
  55. DCA_STEREO_TOTAL,
  56. DCA_3F,
  57. DCA_2F1R,
  58. DCA_3F1R,
  59. DCA_2F2R,
  60. DCA_3F2R,
  61. DCA_4F2R
  62. };
  63. /* -1 are reserved or unknown */
  64. static const int dca_ext_audio_descr_mask[] = {
  65. DCA_EXT_XCH,
  66. -1,
  67. DCA_EXT_X96,
  68. DCA_EXT_XCH | DCA_EXT_X96,
  69. -1,
  70. -1,
  71. DCA_EXT_XXCH,
  72. -1,
  73. };
  74. /* Tables for mapping dts channel configurations to libavcodec multichannel api.
  75. * Some compromises have been made for special configurations. Most configurations
  76. * are never used so complete accuracy is not needed.
  77. *
  78. * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
  79. * S -> side, when both rear and back are configured move one of them to the side channel
  80. * OV -> center back
  81. * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
  82. */
  83. static const uint64_t dca_core_channel_layout[] = {
  84. AV_CH_FRONT_CENTER, ///< 1, A
  85. AV_CH_LAYOUT_STEREO, ///< 2, A + B (dual mono)
  86. AV_CH_LAYOUT_STEREO, ///< 2, L + R (stereo)
  87. AV_CH_LAYOUT_STEREO, ///< 2, (L + R) + (L - R) (sum-difference)
  88. AV_CH_LAYOUT_STEREO, ///< 2, LT + RT (left and right total)
  89. AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER, ///< 3, C + L + R
  90. AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER, ///< 3, L + R + S
  91. AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 4, C + L + R + S
  92. AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 4, L + R + SL + SR
  93. AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
  94. AV_CH_SIDE_RIGHT, ///< 5, C + L + R + SL + SR
  95. AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
  96. AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER, ///< 6, CL + CR + L + R + SL + SR
  97. AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
  98. AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER, ///< 6, C + L + R + LR + RR + OV
  99. AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
  100. AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER |
  101. AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 6, CF + CR + LF + RF + LR + RR
  102. AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
  103. AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
  104. AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR
  105. AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
  106. AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
  107. AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2
  108. AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER |
  109. AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
  110. AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT, ///< 8, CL + C + CR + L + R + SL + S + SR
  111. };
  112. #define DCA_DOLBY 101 /* FIXME */
  113. #define DCA_CHANNEL_BITS 6
  114. #define DCA_CHANNEL_MASK 0x3F
  115. #define DCA_LFE 0x80
  116. #define HEADER_SIZE 14
  117. #define DCA_NSYNCAUX 0x9A1105A0
  118. /** Bit allocation */
  119. typedef struct BitAlloc {
  120. int offset; ///< code values offset
  121. int maxbits[8]; ///< max bits in VLC
  122. int wrap; ///< wrap for get_vlc2()
  123. VLC vlc[8]; ///< actual codes
  124. } BitAlloc;
  125. static BitAlloc dca_bitalloc_index; ///< indexes for samples VLC select
  126. static BitAlloc dca_tmode; ///< transition mode VLCs
  127. static BitAlloc dca_scalefactor; ///< scalefactor VLCs
  128. static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs
  129. static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
  130. int idx)
  131. {
  132. return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
  133. ba->offset;
  134. }
  135. static av_cold void dca_init_vlcs(void)
  136. {
  137. static int vlcs_initialized = 0;
  138. int i, j, c = 14;
  139. static VLC_TYPE dca_table[23622][2];
  140. if (vlcs_initialized)
  141. return;
  142. dca_bitalloc_index.offset = 1;
  143. dca_bitalloc_index.wrap = 2;
  144. for (i = 0; i < 5; i++) {
  145. dca_bitalloc_index.vlc[i].table = &dca_table[ff_dca_vlc_offs[i]];
  146. dca_bitalloc_index.vlc[i].table_allocated = ff_dca_vlc_offs[i + 1] - ff_dca_vlc_offs[i];
  147. init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
  148. bitalloc_12_bits[i], 1, 1,
  149. bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
  150. }
  151. dca_scalefactor.offset = -64;
  152. dca_scalefactor.wrap = 2;
  153. for (i = 0; i < 5; i++) {
  154. dca_scalefactor.vlc[i].table = &dca_table[ff_dca_vlc_offs[i + 5]];
  155. dca_scalefactor.vlc[i].table_allocated = ff_dca_vlc_offs[i + 6] - ff_dca_vlc_offs[i + 5];
  156. init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
  157. scales_bits[i], 1, 1,
  158. scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
  159. }
  160. dca_tmode.offset = 0;
  161. dca_tmode.wrap = 1;
  162. for (i = 0; i < 4; i++) {
  163. dca_tmode.vlc[i].table = &dca_table[ff_dca_vlc_offs[i + 10]];
  164. dca_tmode.vlc[i].table_allocated = ff_dca_vlc_offs[i + 11] - ff_dca_vlc_offs[i + 10];
  165. init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
  166. tmode_bits[i], 1, 1,
  167. tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
  168. }
  169. for (i = 0; i < 10; i++)
  170. for (j = 0; j < 7; j++) {
  171. if (!bitalloc_codes[i][j])
  172. break;
  173. dca_smpl_bitalloc[i + 1].offset = bitalloc_offsets[i];
  174. dca_smpl_bitalloc[i + 1].wrap = 1 + (j > 4);
  175. dca_smpl_bitalloc[i + 1].vlc[j].table = &dca_table[ff_dca_vlc_offs[c]];
  176. dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = ff_dca_vlc_offs[c + 1] - ff_dca_vlc_offs[c];
  177. init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
  178. bitalloc_sizes[i],
  179. bitalloc_bits[i][j], 1, 1,
  180. bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
  181. c++;
  182. }
  183. vlcs_initialized = 1;
  184. }
  185. static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
  186. {
  187. while (len--)
  188. *dst++ = get_bits(gb, bits);
  189. }
  190. static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
  191. {
  192. int i, j;
  193. static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
  194. static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
  195. static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
  196. s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
  197. s->prim_channels = s->total_channels;
  198. if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
  199. s->prim_channels = DCA_PRIM_CHANNELS_MAX;
  200. for (i = base_channel; i < s->prim_channels; i++) {
  201. s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
  202. if (s->subband_activity[i] > DCA_SUBBANDS)
  203. s->subband_activity[i] = DCA_SUBBANDS;
  204. }
  205. for (i = base_channel; i < s->prim_channels; i++) {
  206. s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
  207. if (s->vq_start_subband[i] > DCA_SUBBANDS)
  208. s->vq_start_subband[i] = DCA_SUBBANDS;
  209. }
  210. get_array(&s->gb, s->joint_intensity + base_channel, s->prim_channels - base_channel, 3);
  211. get_array(&s->gb, s->transient_huffman + base_channel, s->prim_channels - base_channel, 2);
  212. get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
  213. get_array(&s->gb, s->bitalloc_huffman + base_channel, s->prim_channels - base_channel, 3);
  214. /* Get codebooks quantization indexes */
  215. if (!base_channel)
  216. memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
  217. for (j = 1; j < 11; j++)
  218. for (i = base_channel; i < s->prim_channels; i++)
  219. s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
  220. /* Get scale factor adjustment */
  221. for (j = 0; j < 11; j++)
  222. for (i = base_channel; i < s->prim_channels; i++)
  223. s->scalefactor_adj[i][j] = 1;
  224. for (j = 1; j < 11; j++)
  225. for (i = base_channel; i < s->prim_channels; i++)
  226. if (s->quant_index_huffman[i][j] < thr[j])
  227. s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
  228. if (s->crc_present) {
  229. /* Audio header CRC check */
  230. get_bits(&s->gb, 16);
  231. }
  232. s->current_subframe = 0;
  233. s->current_subsubframe = 0;
  234. return 0;
  235. }
  236. static int dca_parse_frame_header(DCAContext *s)
  237. {
  238. init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
  239. /* Sync code */
  240. skip_bits_long(&s->gb, 32);
  241. /* Frame header */
  242. s->frame_type = get_bits(&s->gb, 1);
  243. s->samples_deficit = get_bits(&s->gb, 5) + 1;
  244. s->crc_present = get_bits(&s->gb, 1);
  245. s->sample_blocks = get_bits(&s->gb, 7) + 1;
  246. s->frame_size = get_bits(&s->gb, 14) + 1;
  247. if (s->frame_size < 95)
  248. return AVERROR_INVALIDDATA;
  249. s->amode = get_bits(&s->gb, 6);
  250. s->sample_rate = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
  251. if (!s->sample_rate)
  252. return AVERROR_INVALIDDATA;
  253. s->bit_rate_index = get_bits(&s->gb, 5);
  254. s->bit_rate = ff_dca_bit_rates[s->bit_rate_index];
  255. if (!s->bit_rate)
  256. return AVERROR_INVALIDDATA;
  257. skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)
  258. s->dynrange = get_bits(&s->gb, 1);
  259. s->timestamp = get_bits(&s->gb, 1);
  260. s->aux_data = get_bits(&s->gb, 1);
  261. s->hdcd = get_bits(&s->gb, 1);
  262. s->ext_descr = get_bits(&s->gb, 3);
  263. s->ext_coding = get_bits(&s->gb, 1);
  264. s->aspf = get_bits(&s->gb, 1);
  265. s->lfe = get_bits(&s->gb, 2);
  266. s->predictor_history = get_bits(&s->gb, 1);
  267. if (s->lfe > 2) {
  268. av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
  269. return AVERROR_INVALIDDATA;
  270. }
  271. /* TODO: check CRC */
  272. if (s->crc_present)
  273. s->header_crc = get_bits(&s->gb, 16);
  274. s->multirate_inter = get_bits(&s->gb, 1);
  275. s->version = get_bits(&s->gb, 4);
  276. s->copy_history = get_bits(&s->gb, 2);
  277. s->source_pcm_res = get_bits(&s->gb, 3);
  278. s->front_sum = get_bits(&s->gb, 1);
  279. s->surround_sum = get_bits(&s->gb, 1);
  280. s->dialog_norm = get_bits(&s->gb, 4);
  281. /* FIXME: channels mixing levels */
  282. s->output = s->amode;
  283. if (s->lfe)
  284. s->output |= DCA_LFE;
  285. /* Primary audio coding header */
  286. s->subframes = get_bits(&s->gb, 4) + 1;
  287. return dca_parse_audio_coding_header(s, 0);
  288. }
  289. static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
  290. {
  291. if (level < 5) {
  292. /* huffman encoded */
  293. value += get_bitalloc(gb, &dca_scalefactor, level);
  294. value = av_clip(value, 0, (1 << log2range) - 1);
  295. } else if (level < 8) {
  296. if (level + 1 > log2range) {
  297. skip_bits(gb, level + 1 - log2range);
  298. value = get_bits(gb, log2range);
  299. } else {
  300. value = get_bits(gb, level + 1);
  301. }
  302. }
  303. return value;
  304. }
  305. static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
  306. {
  307. /* Primary audio coding side information */
  308. int j, k;
  309. if (get_bits_left(&s->gb) < 0)
  310. return AVERROR_INVALIDDATA;
  311. if (!base_channel) {
  312. s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
  313. s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
  314. }
  315. for (j = base_channel; j < s->prim_channels; j++) {
  316. for (k = 0; k < s->subband_activity[j]; k++)
  317. s->prediction_mode[j][k] = get_bits(&s->gb, 1);
  318. }
  319. /* Get prediction codebook */
  320. for (j = base_channel; j < s->prim_channels; j++) {
  321. for (k = 0; k < s->subband_activity[j]; k++) {
  322. if (s->prediction_mode[j][k] > 0) {
  323. /* (Prediction coefficient VQ address) */
  324. s->prediction_vq[j][k] = get_bits(&s->gb, 12);
  325. }
  326. }
  327. }
  328. /* Bit allocation index */
  329. for (j = base_channel; j < s->prim_channels; j++) {
  330. for (k = 0; k < s->vq_start_subband[j]; k++) {
  331. if (s->bitalloc_huffman[j] == 6)
  332. s->bitalloc[j][k] = get_bits(&s->gb, 5);
  333. else if (s->bitalloc_huffman[j] == 5)
  334. s->bitalloc[j][k] = get_bits(&s->gb, 4);
  335. else if (s->bitalloc_huffman[j] == 7) {
  336. av_log(s->avctx, AV_LOG_ERROR,
  337. "Invalid bit allocation index\n");
  338. return AVERROR_INVALIDDATA;
  339. } else {
  340. s->bitalloc[j][k] =
  341. get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
  342. }
  343. if (s->bitalloc[j][k] > 26) {
  344. av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
  345. j, k, s->bitalloc[j][k]);
  346. return AVERROR_INVALIDDATA;
  347. }
  348. }
  349. }
  350. /* Transition mode */
  351. for (j = base_channel; j < s->prim_channels; j++) {
  352. for (k = 0; k < s->subband_activity[j]; k++) {
  353. s->transition_mode[j][k] = 0;
  354. if (s->subsubframes[s->current_subframe] > 1 &&
  355. k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
  356. s->transition_mode[j][k] =
  357. get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
  358. }
  359. }
  360. }
  361. if (get_bits_left(&s->gb) < 0)
  362. return AVERROR_INVALIDDATA;
  363. for (j = base_channel; j < s->prim_channels; j++) {
  364. const uint32_t *scale_table;
  365. int scale_sum, log_size;
  366. memset(s->scale_factor[j], 0,
  367. s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
  368. if (s->scalefactor_huffman[j] == 6) {
  369. scale_table = ff_dca_scale_factor_quant7;
  370. log_size = 7;
  371. } else {
  372. scale_table = ff_dca_scale_factor_quant6;
  373. log_size = 6;
  374. }
  375. /* When huffman coded, only the difference is encoded */
  376. scale_sum = 0;
  377. for (k = 0; k < s->subband_activity[j]; k++) {
  378. if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
  379. scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
  380. s->scale_factor[j][k][0] = scale_table[scale_sum];
  381. }
  382. if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
  383. /* Get second scale factor */
  384. scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
  385. s->scale_factor[j][k][1] = scale_table[scale_sum];
  386. }
  387. }
  388. }
  389. /* Joint subband scale factor codebook select */
  390. for (j = base_channel; j < s->prim_channels; j++) {
  391. /* Transmitted only if joint subband coding enabled */
  392. if (s->joint_intensity[j] > 0)
  393. s->joint_huff[j] = get_bits(&s->gb, 3);
  394. }
  395. if (get_bits_left(&s->gb) < 0)
  396. return AVERROR_INVALIDDATA;
  397. /* Scale factors for joint subband coding */
  398. for (j = base_channel; j < s->prim_channels; j++) {
  399. int source_channel;
  400. /* Transmitted only if joint subband coding enabled */
  401. if (s->joint_intensity[j] > 0) {
  402. int scale = 0;
  403. source_channel = s->joint_intensity[j] - 1;
  404. /* When huffman coded, only the difference is encoded
  405. * (is this valid as well for joint scales ???) */
  406. for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
  407. scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
  408. s->joint_scale_factor[j][k] = scale; /*joint_scale_table[scale]; */
  409. }
  410. if (!(s->debug_flag & 0x02)) {
  411. av_log(s->avctx, AV_LOG_DEBUG,
  412. "Joint stereo coding not supported\n");
  413. s->debug_flag |= 0x02;
  414. }
  415. }
  416. }
  417. /* Dynamic range coefficient */
  418. if (!base_channel && s->dynrange)
  419. s->dynrange_coef = get_bits(&s->gb, 8);
  420. /* Side information CRC check word */
  421. if (s->crc_present) {
  422. get_bits(&s->gb, 16);
  423. }
  424. /*
  425. * Primary audio data arrays
  426. */
  427. /* VQ encoded high frequency subbands */
  428. for (j = base_channel; j < s->prim_channels; j++)
  429. for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
  430. /* 1 vector -> 32 samples */
  431. s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
  432. /* Low frequency effect data */
  433. if (!base_channel && s->lfe) {
  434. /* LFE samples */
  435. int lfe_samples = 2 * s->lfe * (4 + block_index);
  436. int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
  437. float lfe_scale;
  438. for (j = lfe_samples; j < lfe_end_sample; j++) {
  439. /* Signed 8 bits int */
  440. s->lfe_data[j] = get_sbits(&s->gb, 8);
  441. }
  442. /* Scale factor index */
  443. skip_bits(&s->gb, 1);
  444. s->lfe_scale_factor = ff_dca_scale_factor_quant7[get_bits(&s->gb, 7)];
  445. /* Quantization step size * scale factor */
  446. lfe_scale = 0.035 * s->lfe_scale_factor;
  447. for (j = lfe_samples; j < lfe_end_sample; j++)
  448. s->lfe_data[j] *= lfe_scale;
  449. }
  450. return 0;
  451. }
  452. static void qmf_32_subbands(DCAContext *s, int chans,
  453. float samples_in[32][8], float *samples_out,
  454. float scale)
  455. {
  456. const float *prCoeff;
  457. int sb_act = s->subband_activity[chans];
  458. scale *= sqrt(1 / 8.0);
  459. /* Select filter */
  460. if (!s->multirate_inter) /* Non-perfect reconstruction */
  461. prCoeff = ff_dca_fir_32bands_nonperfect;
  462. else /* Perfect reconstruction */
  463. prCoeff = ff_dca_fir_32bands_perfect;
  464. s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,
  465. s->subband_fir_hist[chans],
  466. &s->hist_index[chans],
  467. s->subband_fir_noidea[chans], prCoeff,
  468. samples_out, s->raXin, scale);
  469. }
  470. static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
  471. int num_deci_sample, float *samples_in,
  472. float *samples_out)
  473. {
  474. /* samples_in: An array holding decimated samples.
  475. * Samples in current subframe starts from samples_in[0],
  476. * while samples_in[-1], samples_in[-2], ..., stores samples
  477. * from last subframe as history.
  478. *
  479. * samples_out: An array holding interpolated samples
  480. */
  481. int idx;
  482. const float *prCoeff;
  483. int deciindex;
  484. /* Select decimation filter */
  485. if (decimation_select == 1) {
  486. idx = 1;
  487. prCoeff = ff_dca_lfe_fir_128;
  488. } else {
  489. idx = 0;
  490. prCoeff = ff_dca_lfe_fir_64;
  491. }
  492. /* Interpolation */
  493. for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
  494. s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);
  495. samples_in++;
  496. samples_out += 2 * 32 * (1 + idx);
  497. }
  498. }
  499. /* downmixing routines */
  500. #define MIX_REAR1(samples, s1, rs, coef) \
  501. samples[0][i] += samples[s1][i] * coef[rs][0]; \
  502. samples[1][i] += samples[s1][i] * coef[rs][1];
  503. #define MIX_REAR2(samples, s1, s2, rs, coef) \
  504. samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
  505. samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
  506. #define MIX_FRONT3(samples, coef) \
  507. t = samples[c][i]; \
  508. u = samples[l][i]; \
  509. v = samples[r][i]; \
  510. samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
  511. samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
  512. #define DOWNMIX_TO_STEREO(op1, op2) \
  513. for (i = 0; i < 256; i++) { \
  514. op1 \
  515. op2 \
  516. }
  517. static void dca_downmix(float **samples, int srcfmt, int lfe_present,
  518. float coef[DCA_PRIM_CHANNELS_MAX + 1][2],
  519. const int8_t *channel_mapping)
  520. {
  521. int c, l, r, sl, sr, s;
  522. int i;
  523. float t, u, v;
  524. switch (srcfmt) {
  525. case DCA_MONO:
  526. case DCA_4F2R:
  527. av_log(NULL, 0, "Not implemented!\n");
  528. break;
  529. case DCA_CHANNEL:
  530. case DCA_STEREO:
  531. case DCA_STEREO_TOTAL:
  532. case DCA_STEREO_SUMDIFF:
  533. break;
  534. case DCA_3F:
  535. c = channel_mapping[0];
  536. l = channel_mapping[1];
  537. r = channel_mapping[2];
  538. DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
  539. break;
  540. case DCA_2F1R:
  541. s = channel_mapping[2];
  542. DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
  543. break;
  544. case DCA_3F1R:
  545. c = channel_mapping[0];
  546. l = channel_mapping[1];
  547. r = channel_mapping[2];
  548. s = channel_mapping[3];
  549. DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
  550. MIX_REAR1(samples, s, 3, coef));
  551. break;
  552. case DCA_2F2R:
  553. sl = channel_mapping[2];
  554. sr = channel_mapping[3];
  555. DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
  556. break;
  557. case DCA_3F2R:
  558. c = channel_mapping[0];
  559. l = channel_mapping[1];
  560. r = channel_mapping[2];
  561. sl = channel_mapping[3];
  562. sr = channel_mapping[4];
  563. DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
  564. MIX_REAR2(samples, sl, sr, 3, coef));
  565. break;
  566. }
  567. if (lfe_present) {
  568. int lf_buf = ff_dca_lfe_index[srcfmt];
  569. int lf_idx = ff_dca_channels[srcfmt];
  570. for (i = 0; i < 256; i++) {
  571. samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];
  572. samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];
  573. }
  574. }
  575. }
  576. #ifndef decode_blockcodes
  577. /* Very compact version of the block code decoder that does not use table
  578. * look-up but is slightly slower */
  579. static int decode_blockcode(int code, int levels, int32_t *values)
  580. {
  581. int i;
  582. int offset = (levels - 1) >> 1;
  583. for (i = 0; i < 4; i++) {
  584. int div = FASTDIV(code, levels);
  585. values[i] = code - offset - div * levels;
  586. code = div;
  587. }
  588. return code;
  589. }
  590. static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)
  591. {
  592. return decode_blockcode(code1, levels, values) |
  593. decode_blockcode(code2, levels, values + 4);
  594. }
  595. #endif
  596. static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
  597. static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
  598. static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
  599. {
  600. int k, l;
  601. int subsubframe = s->current_subsubframe;
  602. const float *quant_step_table;
  603. /* FIXME */
  604. float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
  605. LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);
  606. /*
  607. * Audio data
  608. */
  609. /* Select quantization step size table */
  610. if (s->bit_rate_index == 0x1f)
  611. quant_step_table = ff_dca_lossless_quant_d;
  612. else
  613. quant_step_table = ff_dca_lossy_quant_d;
  614. for (k = base_channel; k < s->prim_channels; k++) {
  615. float rscale[DCA_SUBBANDS];
  616. if (get_bits_left(&s->gb) < 0)
  617. return AVERROR_INVALIDDATA;
  618. for (l = 0; l < s->vq_start_subband[k]; l++) {
  619. int m;
  620. /* Select the mid-tread linear quantizer */
  621. int abits = s->bitalloc[k][l];
  622. float quant_step_size = quant_step_table[abits];
  623. /*
  624. * Determine quantization index code book and its type
  625. */
  626. /* Select quantization index code book */
  627. int sel = s->quant_index_huffman[k][abits];
  628. /*
  629. * Extract bits from the bit stream
  630. */
  631. if (!abits) {
  632. rscale[l] = 0;
  633. memset(block + 8 * l, 0, 8 * sizeof(block[0]));
  634. } else {
  635. /* Deal with transients */
  636. int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
  637. rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *
  638. s->scalefactor_adj[k][sel];
  639. if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
  640. if (abits <= 7) {
  641. /* Block code */
  642. int block_code1, block_code2, size, levels, err;
  643. size = abits_sizes[abits - 1];
  644. levels = abits_levels[abits - 1];
  645. block_code1 = get_bits(&s->gb, size);
  646. block_code2 = get_bits(&s->gb, size);
  647. err = decode_blockcodes(block_code1, block_code2,
  648. levels, block + 8 * l);
  649. if (err) {
  650. av_log(s->avctx, AV_LOG_ERROR,
  651. "ERROR: block code look-up failed\n");
  652. return AVERROR_INVALIDDATA;
  653. }
  654. } else {
  655. /* no coding */
  656. for (m = 0; m < 8; m++)
  657. block[8 * l + m] = get_sbits(&s->gb, abits - 3);
  658. }
  659. } else {
  660. /* Huffman coded */
  661. for (m = 0; m < 8; m++)
  662. block[8 * l + m] = get_bitalloc(&s->gb,
  663. &dca_smpl_bitalloc[abits], sel);
  664. }
  665. }
  666. }
  667. s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],
  668. block, rscale, 8 * s->vq_start_subband[k]);
  669. for (l = 0; l < s->vq_start_subband[k]; l++) {
  670. int m;
  671. /*
  672. * Inverse ADPCM if in prediction mode
  673. */
  674. if (s->prediction_mode[k][l]) {
  675. int n;
  676. if (s->predictor_history)
  677. subband_samples[k][l][0] += (ff_dca_adpcm_vb[s->prediction_vq[k][l]][0] *
  678. s->subband_samples_hist[k][l][3] +
  679. ff_dca_adpcm_vb[s->prediction_vq[k][l]][1] *
  680. s->subband_samples_hist[k][l][2] +
  681. ff_dca_adpcm_vb[s->prediction_vq[k][l]][2] *
  682. s->subband_samples_hist[k][l][1] +
  683. ff_dca_adpcm_vb[s->prediction_vq[k][l]][3] *
  684. s->subband_samples_hist[k][l][0]) *
  685. (1.0f / 8192);
  686. for (m = 1; m < 8; m++) {
  687. float sum = ff_dca_adpcm_vb[s->prediction_vq[k][l]][0] *
  688. subband_samples[k][l][m - 1];
  689. for (n = 2; n <= 4; n++)
  690. if (m >= n)
  691. sum += ff_dca_adpcm_vb[s->prediction_vq[k][l]][n - 1] *
  692. subband_samples[k][l][m - n];
  693. else if (s->predictor_history)
  694. sum += ff_dca_adpcm_vb[s->prediction_vq[k][l]][n - 1] *
  695. s->subband_samples_hist[k][l][m - n + 4];
  696. subband_samples[k][l][m] += sum * 1.0f / 8192;
  697. }
  698. }
  699. }
  700. /*
  701. * Decode VQ encoded high frequencies
  702. */
  703. if (s->subband_activity[k] > s->vq_start_subband[k]) {
  704. if (!s->debug_flag & 0x01) {
  705. av_log(s->avctx, AV_LOG_DEBUG,
  706. "Stream with high frequencies VQ coding\n");
  707. s->debug_flag |= 0x01;
  708. }
  709. s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k],
  710. ff_dca_high_freq_vq, subsubframe * 8,
  711. s->scale_factor[k], s->vq_start_subband[k],
  712. s->subband_activity[k]);
  713. }
  714. }
  715. /* Check for DSYNC after subsubframe */
  716. if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
  717. if (get_bits(&s->gb, 16) != 0xFFFF) {
  718. av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
  719. return AVERROR_INVALIDDATA;
  720. }
  721. }
  722. /* Backup predictor history for adpcm */
  723. for (k = base_channel; k < s->prim_channels; k++)
  724. for (l = 0; l < s->vq_start_subband[k]; l++)
  725. AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);
  726. return 0;
  727. }
  728. static int dca_filter_channels(DCAContext *s, int block_index)
  729. {
  730. float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
  731. int k;
  732. /* 32 subbands QMF */
  733. for (k = 0; k < s->prim_channels; k++) {
  734. if (s->channel_order_tab[k] >= 0)
  735. qmf_32_subbands(s, k, subband_samples[k],
  736. s->samples_chanptr[s->channel_order_tab[k]],
  737. M_SQRT1_2 / 32768.0);
  738. }
  739. /* Generate LFE samples for this subsubframe FIXME!!! */
  740. if (s->lfe) {
  741. lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
  742. s->lfe_data + 2 * s->lfe * (block_index + 4),
  743. s->samples_chanptr[ff_dca_lfe_index[s->amode]]);
  744. /* Outputs 20bits pcm samples */
  745. }
  746. /* Downmixing to Stereo */
  747. if (s->prim_channels + !!s->lfe > 2 &&
  748. s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
  749. dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,
  750. s->channel_order_tab);
  751. }
  752. return 0;
  753. }
  754. static int dca_subframe_footer(DCAContext *s, int base_channel)
  755. {
  756. int in, out, aux_data_count, aux_data_end, reserved;
  757. uint32_t nsyncaux;
  758. /*
  759. * Unpack optional information
  760. */
  761. /* presumably optional information only appears in the core? */
  762. if (!base_channel) {
  763. if (s->timestamp)
  764. skip_bits_long(&s->gb, 32);
  765. if (s->aux_data) {
  766. aux_data_count = get_bits(&s->gb, 6);
  767. // align (32-bit)
  768. skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
  769. aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);
  770. if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {
  771. av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",
  772. nsyncaux);
  773. return AVERROR_INVALIDDATA;
  774. }
  775. if (get_bits1(&s->gb)) { // bAUXTimeStampFlag
  776. avpriv_request_sample(s->avctx,
  777. "Auxiliary Decode Time Stamp Flag");
  778. // align (4-bit)
  779. skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);
  780. // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)
  781. skip_bits_long(&s->gb, 44);
  782. }
  783. if ((s->core_downmix = get_bits1(&s->gb))) {
  784. int am = get_bits(&s->gb, 3);
  785. switch (am) {
  786. case 0:
  787. s->core_downmix_amode = DCA_MONO;
  788. break;
  789. case 1:
  790. s->core_downmix_amode = DCA_STEREO;
  791. break;
  792. case 2:
  793. s->core_downmix_amode = DCA_STEREO_TOTAL;
  794. break;
  795. case 3:
  796. s->core_downmix_amode = DCA_3F;
  797. break;
  798. case 4:
  799. s->core_downmix_amode = DCA_2F1R;
  800. break;
  801. case 5:
  802. s->core_downmix_amode = DCA_2F2R;
  803. break;
  804. case 6:
  805. s->core_downmix_amode = DCA_3F1R;
  806. break;
  807. default:
  808. av_log(s->avctx, AV_LOG_ERROR,
  809. "Invalid mode %d for embedded downmix coefficients\n",
  810. am);
  811. return AVERROR_INVALIDDATA;
  812. }
  813. for (out = 0; out < ff_dca_channels[s->core_downmix_amode]; out++) {
  814. for (in = 0; in < s->prim_channels + !!s->lfe; in++) {
  815. uint16_t tmp = get_bits(&s->gb, 9);
  816. if ((tmp & 0xFF) > 241) {
  817. av_log(s->avctx, AV_LOG_ERROR,
  818. "Invalid downmix coefficient code %"PRIu16"\n",
  819. tmp);
  820. return AVERROR_INVALIDDATA;
  821. }
  822. s->core_downmix_codes[in][out] = tmp;
  823. }
  824. }
  825. }
  826. align_get_bits(&s->gb); // byte align
  827. skip_bits(&s->gb, 16); // nAUXCRC16
  828. // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)
  829. if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {
  830. av_log(s->avctx, AV_LOG_ERROR,
  831. "Overread auxiliary data by %d bits\n", -reserved);
  832. return AVERROR_INVALIDDATA;
  833. } else if (reserved) {
  834. avpriv_request_sample(s->avctx,
  835. "Core auxiliary data reserved content");
  836. skip_bits_long(&s->gb, reserved);
  837. }
  838. }
  839. if (s->crc_present && s->dynrange)
  840. get_bits(&s->gb, 16);
  841. }
  842. return 0;
  843. }
  844. /**
  845. * Decode a dca frame block
  846. *
  847. * @param s pointer to the DCAContext
  848. */
  849. static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
  850. {
  851. int ret;
  852. /* Sanity check */
  853. if (s->current_subframe >= s->subframes) {
  854. av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
  855. s->current_subframe, s->subframes);
  856. return AVERROR_INVALIDDATA;
  857. }
  858. if (!s->current_subsubframe) {
  859. /* Read subframe header */
  860. if ((ret = dca_subframe_header(s, base_channel, block_index)))
  861. return ret;
  862. }
  863. /* Read subsubframe */
  864. if ((ret = dca_subsubframe(s, base_channel, block_index)))
  865. return ret;
  866. /* Update state */
  867. s->current_subsubframe++;
  868. if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
  869. s->current_subsubframe = 0;
  870. s->current_subframe++;
  871. }
  872. if (s->current_subframe >= s->subframes) {
  873. /* Read subframe footer */
  874. if ((ret = dca_subframe_footer(s, base_channel)))
  875. return ret;
  876. }
  877. return 0;
  878. }
  879. static float dca_dmix_code(unsigned code)
  880. {
  881. int sign = (code >> 8) - 1;
  882. code &= 0xff;
  883. return ((ff_dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1U << 15));
  884. }
  885. /**
  886. * Main frame decoding function
  887. * FIXME add arguments
  888. */
  889. static int dca_decode_frame(AVCodecContext *avctx, void *data,
  890. int *got_frame_ptr, AVPacket *avpkt)
  891. {
  892. AVFrame *frame = data;
  893. const uint8_t *buf = avpkt->data;
  894. int buf_size = avpkt->size;
  895. int lfe_samples;
  896. int num_core_channels = 0;
  897. int i, ret;
  898. float **samples_flt;
  899. DCAContext *s = avctx->priv_data;
  900. int channels, full_channels;
  901. int core_ss_end;
  902. s->xch_present = 0;
  903. s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
  904. DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
  905. if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
  906. av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
  907. return AVERROR_INVALIDDATA;
  908. }
  909. if ((ret = dca_parse_frame_header(s)) < 0) {
  910. // seems like the frame is corrupt, try with the next one
  911. return ret;
  912. }
  913. // set AVCodec values with parsed data
  914. avctx->sample_rate = s->sample_rate;
  915. avctx->bit_rate = s->bit_rate;
  916. s->profile = FF_PROFILE_DTS;
  917. for (i = 0; i < (s->sample_blocks / 8); i++) {
  918. if ((ret = dca_decode_block(s, 0, i))) {
  919. av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
  920. return ret;
  921. }
  922. }
  923. /* record number of core channels incase less than max channels are requested */
  924. num_core_channels = s->prim_channels;
  925. if (s->ext_coding)
  926. s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
  927. else
  928. s->core_ext_mask = 0;
  929. core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
  930. /* only scan for extensions if ext_descr was unknown or indicated a
  931. * supported XCh extension */
  932. if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
  933. /* if ext_descr was unknown, clear s->core_ext_mask so that the
  934. * extensions scan can fill it up */
  935. s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
  936. /* extensions start at 32-bit boundaries into bitstream */
  937. skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
  938. while (core_ss_end - get_bits_count(&s->gb) >= 32) {
  939. uint32_t bits = get_bits_long(&s->gb, 32);
  940. switch (bits) {
  941. case 0x5a5a5a5a: {
  942. int ext_amode, xch_fsize;
  943. s->xch_base_channel = s->prim_channels;
  944. /* validate sync word using XCHFSIZE field */
  945. xch_fsize = show_bits(&s->gb, 10);
  946. if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
  947. (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
  948. continue;
  949. /* skip length-to-end-of-frame field for the moment */
  950. skip_bits(&s->gb, 10);
  951. s->core_ext_mask |= DCA_EXT_XCH;
  952. /* extension amode(number of channels in extension) should be 1 */
  953. /* AFAIK XCh is not used for more channels */
  954. if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
  955. av_log(avctx, AV_LOG_ERROR,
  956. "XCh extension amode %d not supported!\n",
  957. ext_amode);
  958. continue;
  959. }
  960. /* much like core primary audio coding header */
  961. dca_parse_audio_coding_header(s, s->xch_base_channel);
  962. for (i = 0; i < (s->sample_blocks / 8); i++)
  963. if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
  964. av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
  965. continue;
  966. }
  967. s->xch_present = 1;
  968. break;
  969. }
  970. case 0x47004a03:
  971. /* XXCh: extended channels */
  972. /* usually found either in core or HD part in DTS-HD HRA streams,
  973. * but not in DTS-ES which contains XCh extensions instead */
  974. s->core_ext_mask |= DCA_EXT_XXCH;
  975. break;
  976. case 0x1d95f262: {
  977. int fsize96 = show_bits(&s->gb, 12) + 1;
  978. if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
  979. continue;
  980. av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
  981. get_bits_count(&s->gb));
  982. skip_bits(&s->gb, 12);
  983. av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
  984. av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
  985. s->core_ext_mask |= DCA_EXT_X96;
  986. break;
  987. }
  988. }
  989. skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
  990. }
  991. } else {
  992. /* no supported extensions, skip the rest of the core substream */
  993. skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
  994. }
  995. if (s->core_ext_mask & DCA_EXT_X96)
  996. s->profile = FF_PROFILE_DTS_96_24;
  997. else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
  998. s->profile = FF_PROFILE_DTS_ES;
  999. /* check for ExSS (HD part) */
  1000. if (s->dca_buffer_size - s->frame_size > 32 &&
  1001. get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
  1002. ff_dca_exss_parse_header(s);
  1003. avctx->profile = s->profile;
  1004. full_channels = channels = s->prim_channels + !!s->lfe;
  1005. if (s->amode < 16) {
  1006. avctx->channel_layout = dca_core_channel_layout[s->amode];
  1007. if (s->prim_channels + !!s->lfe > 2 &&
  1008. avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
  1009. /*
  1010. * Neither the core's auxiliary data nor our default tables contain
  1011. * downmix coefficients for the additional channel coded in the XCh
  1012. * extension, so when we're doing a Stereo downmix, don't decode it.
  1013. */
  1014. s->xch_disable = 1;
  1015. }
  1016. #if FF_API_REQUEST_CHANNELS
  1017. FF_DISABLE_DEPRECATION_WARNINGS
  1018. if (s->xch_present && !s->xch_disable &&
  1019. (!avctx->request_channels ||
  1020. avctx->request_channels > num_core_channels + !!s->lfe)) {
  1021. FF_ENABLE_DEPRECATION_WARNINGS
  1022. #else
  1023. if (s->xch_present && !s->xch_disable) {
  1024. #endif
  1025. avctx->channel_layout |= AV_CH_BACK_CENTER;
  1026. if (s->lfe) {
  1027. avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
  1028. s->channel_order_tab = ff_dca_channel_reorder_lfe_xch[s->amode];
  1029. } else {
  1030. s->channel_order_tab = ff_dca_channel_reorder_nolfe_xch[s->amode];
  1031. }
  1032. } else {
  1033. channels = num_core_channels + !!s->lfe;
  1034. s->xch_present = 0; /* disable further xch processing */
  1035. if (s->lfe) {
  1036. avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
  1037. s->channel_order_tab = ff_dca_channel_reorder_lfe[s->amode];
  1038. } else
  1039. s->channel_order_tab = ff_dca_channel_reorder_nolfe[s->amode];
  1040. }
  1041. if (channels > !!s->lfe &&
  1042. s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
  1043. return AVERROR_INVALIDDATA;
  1044. if (num_core_channels + !!s->lfe > 2 &&
  1045. avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
  1046. channels = 2;
  1047. s->output = s->prim_channels == 2 ? s->amode : DCA_STEREO;
  1048. avctx->channel_layout = AV_CH_LAYOUT_STEREO;
  1049. /* Stereo downmix coefficients
  1050. *
  1051. * The decoder can only downmix to 2-channel, so we need to ensure
  1052. * embedded downmix coefficients are actually targeting 2-channel.
  1053. */
  1054. if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||
  1055. s->core_downmix_amode == DCA_STEREO_TOTAL)) {
  1056. for (i = 0; i < num_core_channels + !!s->lfe; i++) {
  1057. /* Range checked earlier */
  1058. s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);
  1059. s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);
  1060. }
  1061. s->output = s->core_downmix_amode;
  1062. } else {
  1063. int am = s->amode & DCA_CHANNEL_MASK;
  1064. if (am >= FF_ARRAY_ELEMS(ff_dca_default_coeffs)) {
  1065. av_log(s->avctx, AV_LOG_ERROR,
  1066. "Invalid channel mode %d\n", am);
  1067. return AVERROR_INVALIDDATA;
  1068. }
  1069. if (num_core_channels + !!s->lfe >
  1070. FF_ARRAY_ELEMS(ff_dca_default_coeffs[0])) {
  1071. avpriv_request_sample(s->avctx, "Downmixing %d channels",
  1072. s->prim_channels + !!s->lfe);
  1073. return AVERROR_PATCHWELCOME;
  1074. }
  1075. for (i = 0; i < num_core_channels + !!s->lfe; i++) {
  1076. s->downmix_coef[i][0] = ff_dca_default_coeffs[am][i][0];
  1077. s->downmix_coef[i][1] = ff_dca_default_coeffs[am][i][1];
  1078. }
  1079. }
  1080. av_dlog(s->avctx, "Stereo downmix coeffs:\n");
  1081. for (i = 0; i < num_core_channels + !!s->lfe; i++) {
  1082. av_dlog(s->avctx, "L, input channel %d = %f\n", i,
  1083. s->downmix_coef[i][0]);
  1084. av_dlog(s->avctx, "R, input channel %d = %f\n", i,
  1085. s->downmix_coef[i][1]);
  1086. }
  1087. av_dlog(s->avctx, "\n");
  1088. }
  1089. } else {
  1090. av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
  1091. return AVERROR_INVALIDDATA;
  1092. }
  1093. avctx->channels = channels;
  1094. /* get output buffer */
  1095. frame->nb_samples = 256 * (s->sample_blocks / 8);
  1096. if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
  1097. av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  1098. return ret;
  1099. }
  1100. samples_flt = (float **) frame->extended_data;
  1101. /* allocate buffer for extra channels if downmixing */
  1102. if (avctx->channels < full_channels) {
  1103. ret = av_samples_get_buffer_size(NULL, full_channels - channels,
  1104. frame->nb_samples,
  1105. avctx->sample_fmt, 0);
  1106. if (ret < 0)
  1107. return ret;
  1108. av_fast_malloc(&s->extra_channels_buffer,
  1109. &s->extra_channels_buffer_size, ret);
  1110. if (!s->extra_channels_buffer)
  1111. return AVERROR(ENOMEM);
  1112. ret = av_samples_fill_arrays((uint8_t **) s->extra_channels, NULL,
  1113. s->extra_channels_buffer,
  1114. full_channels - channels,
  1115. frame->nb_samples, avctx->sample_fmt, 0);
  1116. if (ret < 0)
  1117. return ret;
  1118. }
  1119. /* filter to get final output */
  1120. for (i = 0; i < (s->sample_blocks / 8); i++) {
  1121. int ch;
  1122. for (ch = 0; ch < channels; ch++)
  1123. s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
  1124. for (; ch < full_channels; ch++)
  1125. s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
  1126. dca_filter_channels(s, i);
  1127. /* If this was marked as a DTS-ES stream we need to subtract back- */
  1128. /* channel from SL & SR to remove matrixed back-channel signal */
  1129. if ((s->source_pcm_res & 1) && s->xch_present) {
  1130. float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
  1131. float *lt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
  1132. float *rt_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
  1133. s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
  1134. s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
  1135. }
  1136. }
  1137. /* update lfe history */
  1138. lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
  1139. for (i = 0; i < 2 * s->lfe * 4; i++)
  1140. s->lfe_data[i] = s->lfe_data[i + lfe_samples];
  1141. /* AVMatrixEncoding
  1142. *
  1143. * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */
  1144. ret = ff_side_data_update_matrix_encoding(frame,
  1145. (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?
  1146. AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);
  1147. if (ret < 0)
  1148. return ret;
  1149. *got_frame_ptr = 1;
  1150. return buf_size;
  1151. }
  1152. /**
  1153. * DCA initialization
  1154. *
  1155. * @param avctx pointer to the AVCodecContext
  1156. */
  1157. static av_cold int dca_decode_init(AVCodecContext *avctx)
  1158. {
  1159. DCAContext *s = avctx->priv_data;
  1160. s->avctx = avctx;
  1161. dca_init_vlcs();
  1162. avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
  1163. ff_mdct_init(&s->imdct, 6, 1, 1.0);
  1164. ff_synth_filter_init(&s->synth);
  1165. ff_dcadsp_init(&s->dcadsp);
  1166. ff_fmt_convert_init(&s->fmt_conv, avctx);
  1167. avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
  1168. /* allow downmixing to stereo */
  1169. #if FF_API_REQUEST_CHANNELS
  1170. FF_DISABLE_DEPRECATION_WARNINGS
  1171. if (avctx->request_channels == 2)
  1172. avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
  1173. FF_ENABLE_DEPRECATION_WARNINGS
  1174. #endif
  1175. if (avctx->channels > 2 &&
  1176. avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
  1177. avctx->channels = 2;
  1178. return 0;
  1179. }
  1180. static av_cold int dca_decode_end(AVCodecContext *avctx)
  1181. {
  1182. DCAContext *s = avctx->priv_data;
  1183. ff_mdct_end(&s->imdct);
  1184. av_freep(&s->extra_channels_buffer);
  1185. return 0;
  1186. }
  1187. static const AVProfile profiles[] = {
  1188. { FF_PROFILE_DTS, "DTS" },
  1189. { FF_PROFILE_DTS_ES, "DTS-ES" },
  1190. { FF_PROFILE_DTS_96_24, "DTS 96/24" },
  1191. { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
  1192. { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
  1193. { FF_PROFILE_UNKNOWN },
  1194. };
  1195. static const AVOption options[] = {
  1196. { "disable_xch", "disable decoding of the XCh extension", offsetof(DCAContext, xch_disable), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM },
  1197. { NULL },
  1198. };
  1199. static const AVClass dca_decoder_class = {
  1200. .class_name = "DCA decoder",
  1201. .item_name = av_default_item_name,
  1202. .option = options,
  1203. .version = LIBAVUTIL_VERSION_INT,
  1204. };
  1205. AVCodec ff_dca_decoder = {
  1206. .name = "dca",
  1207. .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
  1208. .type = AVMEDIA_TYPE_AUDIO,
  1209. .id = AV_CODEC_ID_DTS,
  1210. .priv_data_size = sizeof(DCAContext),
  1211. .init = dca_decode_init,
  1212. .decode = dca_decode_frame,
  1213. .close = dca_decode_end,
  1214. .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
  1215. .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
  1216. AV_SAMPLE_FMT_NONE },
  1217. .profiles = NULL_IF_CONFIG_SMALL(profiles),
  1218. .priv_class = &dca_decoder_class,
  1219. };