falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
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.
69771 Commits
32 Branches
310MB
Tree: 6c44dd6c6e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6c44dd6c6e'
${ noResults }
FFmpeg/libavcodec/dcadec.c

2052 lines
75KB
Raw Blame History 

  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 FFmpeg.

  9.  *

  10.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; if not, write to the Free Software

  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  23.  */

  24. 

  25. #include <math.h>

  26. #include <stddef.h>

  27. #include <stdio.h>

  28. 

  29. #include "libavutil/channel_layout.h"

  30. #include "libavutil/common.h"

  31. #include "libavutil/float_dsp.h"

  32. #include "libavutil/internal.h"

  33. #include "libavutil/intreadwrite.h"

  34. #include "libavutil/mathematics.h"

  35. #include "libavutil/opt.h"

  36. #include "libavutil/samplefmt.h"

  37. 

  38. #include "avcodec.h"

  39. #include "dca.h"

  40. #include "dcadata.h"

  41. #include "dcadsp.h"

  42. #include "dcahuff.h"

  43. #include "dca_exss.h"

  44. #include "fft.h"

  45. #include "fmtconvert.h"

  46. #include "get_bits.h"

  47. #include "internal.h"

  48. #include "mathops.h"

  49. #include "synth_filter.h"

  50. 

  51. #if ARCH_ARM

  52. #   include "arm/dca.h"

  53. #endif

  54. 

  55. enum DCAMode {

  56.     DCA_MONO = 0,

  57.     DCA_CHANNEL,

  58.     DCA_STEREO,

  59.     DCA_STEREO_SUMDIFF,

  60.     DCA_STEREO_TOTAL,

  61.     DCA_3F,

  62.     DCA_2F1R,

  63.     DCA_3F1R,

  64.     DCA_2F2R,

  65.     DCA_3F2R,

  66.     DCA_4F2R

  67. };

  68. 

  69. 

  70. enum DCAXxchSpeakerMask {

  71.     DCA_XXCH_FRONT_CENTER          = 0x0000001,

  72.     DCA_XXCH_FRONT_LEFT            = 0x0000002,

  73.     DCA_XXCH_FRONT_RIGHT           = 0x0000004,

  74.     DCA_XXCH_SIDE_REAR_LEFT        = 0x0000008,

  75.     DCA_XXCH_SIDE_REAR_RIGHT       = 0x0000010,

  76.     DCA_XXCH_LFE1                  = 0x0000020,

  77.     DCA_XXCH_REAR_CENTER           = 0x0000040,

  78.     DCA_XXCH_SURROUND_REAR_LEFT    = 0x0000080,

  79.     DCA_XXCH_SURROUND_REAR_RIGHT   = 0x0000100,

  80.     DCA_XXCH_SIDE_SURROUND_LEFT    = 0x0000200,

  81.     DCA_XXCH_SIDE_SURROUND_RIGHT   = 0x0000400,

  82.     DCA_XXCH_FRONT_CENTER_LEFT     = 0x0000800,

  83.     DCA_XXCH_FRONT_CENTER_RIGHT    = 0x0001000,

  84.     DCA_XXCH_FRONT_HIGH_LEFT       = 0x0002000,

  85.     DCA_XXCH_FRONT_HIGH_CENTER     = 0x0004000,

  86.     DCA_XXCH_FRONT_HIGH_RIGHT      = 0x0008000,

  87.     DCA_XXCH_LFE2                  = 0x0010000,

  88.     DCA_XXCH_SIDE_FRONT_LEFT       = 0x0020000,

  89.     DCA_XXCH_SIDE_FRONT_RIGHT      = 0x0040000,

  90.     DCA_XXCH_OVERHEAD              = 0x0080000,

  91.     DCA_XXCH_SIDE_HIGH_LEFT        = 0x0100000,

  92.     DCA_XXCH_SIDE_HIGH_RIGHT       = 0x0200000,

  93.     DCA_XXCH_REAR_HIGH_CENTER      = 0x0400000,

  94.     DCA_XXCH_REAR_HIGH_LEFT        = 0x0800000,

  95.     DCA_XXCH_REAR_HIGH_RIGHT       = 0x1000000,

  96.     DCA_XXCH_REAR_LOW_CENTER       = 0x2000000,

  97.     DCA_XXCH_REAR_LOW_LEFT         = 0x4000000,

  98.     DCA_XXCH_REAR_LOW_RIGHT        = 0x8000000,

  99. };

  100. 

  101. static const uint32_t map_xxch_to_native[28] = {

  102.     AV_CH_FRONT_CENTER,

  103.     AV_CH_FRONT_LEFT,

  104.     AV_CH_FRONT_RIGHT,

  105.     AV_CH_SIDE_LEFT,

  106.     AV_CH_SIDE_RIGHT,

  107.     AV_CH_LOW_FREQUENCY,

  108.     AV_CH_BACK_CENTER,

  109.     AV_CH_BACK_LEFT,

  110.     AV_CH_BACK_RIGHT,

  111.     AV_CH_SIDE_LEFT,           /* side surround left -- dup sur side L */

  112.     AV_CH_SIDE_RIGHT,          /* side surround right -- dup sur side R */

  113.     AV_CH_FRONT_LEFT_OF_CENTER,

  114.     AV_CH_FRONT_RIGHT_OF_CENTER,

  115.     AV_CH_TOP_FRONT_LEFT,

  116.     AV_CH_TOP_FRONT_CENTER,

  117.     AV_CH_TOP_FRONT_RIGHT,

  118.     AV_CH_LOW_FREQUENCY,        /* lfe2 -- duplicate lfe1 position */

  119.     AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */

  120.     AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */

  121.     AV_CH_TOP_CENTER,           /* overhead */

  122.     AV_CH_TOP_FRONT_LEFT,       /* side high left -- dup */

  123.     AV_CH_TOP_FRONT_RIGHT,      /* side high right -- dup */

  124.     AV_CH_TOP_BACK_CENTER,

  125.     AV_CH_TOP_BACK_LEFT,

  126.     AV_CH_TOP_BACK_RIGHT,

  127.     AV_CH_BACK_CENTER,          /* rear low center -- dup */

  128.     AV_CH_BACK_LEFT,            /* rear low left -- dup */

  129.     AV_CH_BACK_RIGHT            /* read low right -- dup  */

  130. };

  131. 

  132. /* -1 are reserved or unknown */

  133. static const int dca_ext_audio_descr_mask[] = {

  134.     DCA_EXT_XCH,

  135.     -1,

  136.     DCA_EXT_X96,

  137.     DCA_EXT_XCH | DCA_EXT_X96,

  138.     -1,

  139.     -1,

  140.     DCA_EXT_XXCH,

  141.     -1,

  142. };

  143. 

  144. /* Tables for mapping dts channel configurations to libavcodec multichannel api.

  145.  * Some compromises have been made for special configurations. Most configurations

  146.  * are never used so complete accuracy is not needed.

  147.  *

  148.  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.

  149.  * S  -> side, when both rear and back are configured move one of them to the side channel

  150.  * OV -> center back

  151.  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO

  152.  */

  153. static const uint64_t dca_core_channel_layout[] = {

  154.     AV_CH_FRONT_CENTER,                                                     ///< 1, A

  155.     AV_CH_LAYOUT_STEREO,                                                    ///< 2, A + B (dual mono)

  156.     AV_CH_LAYOUT_STEREO,                                                    ///< 2, L + R (stereo)

  157.     AV_CH_LAYOUT_STEREO,                                                    ///< 2, (L + R) + (L - R) (sum-difference)

  158.     AV_CH_LAYOUT_STEREO,                                                    ///< 2, LT + RT (left and right total)

  159.     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               ///< 3, C + L + R

  160.     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                ///< 3, L + R + S

  161.     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           ///< 4, C + L + R + S

  162.     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               ///< 4, L + R + SL + SR

  163. 

  164.     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |

  165.     AV_CH_SIDE_RIGHT,                                                       ///< 5, C + L + R + SL + SR

  166. 

  167.     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |

  168.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               ///< 6, CL + CR + L + R + SL + SR

  169. 

  170.     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |

  171.     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                ///< 6, C + L + R + LR + RR + OV

  172. 

  173.     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |

  174.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |

  175.     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 6, CF + CR + LF + RF + LR + RR

  176. 

  177.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |

  178.     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |

  179.     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     ///< 7, CL + C + CR + L + R + SL + SR

  180. 

  181.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |

  182.     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |

  183.     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     ///< 8, CL + CR + L + R + SL1 + SL2 + SR1 + SR2

  184. 

  185.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |

  186.     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |

  187.     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 ///< 8, CL + C + CR + L + R + SL + S + SR

  188. };

  189. 

  190. static const int8_t dca_lfe_index[] = {

  191.     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3

  192. };

  193. 

  194. static const int8_t dca_channel_reorder_lfe[][9] = {

  195.     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },

  196.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  197.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  198.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  199.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  200.     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },

  201.     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },

  202.     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },

  203.     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },

  204.     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },

  205.     { 3,  4,  0,  1,  5,  6, -1, -1, -1 },

  206.     { 2,  0,  1,  4,  5,  6, -1, -1, -1 },

  207.     { 0,  6,  4,  5,  2,  3, -1, -1, -1 },

  208.     { 4,  2,  5,  0,  1,  6,  7, -1, -1 },

  209.     { 5,  6,  0,  1,  7,  3,  8,  4, -1 },

  210.     { 4,  2,  5,  0,  1,  6,  8,  7, -1 },

  211. };

  212. 

  213. static const int8_t dca_channel_reorder_lfe_xch[][9] = {

  214.     { 0,  2, -1, -1, -1, -1, -1, -1, -1 },

  215.     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },

  216.     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },

  217.     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },

  218.     { 0,  1,  3, -1, -1, -1, -1, -1, -1 },

  219.     { 2,  0,  1,  4, -1, -1, -1, -1, -1 },

  220.     { 0,  1,  3,  4, -1, -1, -1, -1, -1 },

  221.     { 2,  0,  1,  4,  5, -1, -1, -1, -1 },

  222.     { 0,  1,  4,  5,  3, -1, -1, -1, -1 },

  223.     { 2,  0,  1,  5,  6,  4, -1, -1, -1 },

  224.     { 3,  4,  0,  1,  6,  7,  5, -1, -1 },

  225.     { 2,  0,  1,  4,  5,  6,  7, -1, -1 },

  226.     { 0,  6,  4,  5,  2,  3,  7, -1, -1 },

  227.     { 4,  2,  5,  0,  1,  7,  8,  6, -1 },

  228.     { 5,  6,  0,  1,  8,  3,  9,  4,  7 },

  229.     { 4,  2,  5,  0,  1,  6,  9,  8,  7 },

  230. };

  231. 

  232. static const int8_t dca_channel_reorder_nolfe[][9] = {

  233.     { 0, -1, -1, -1, -1, -1, -1, -1, -1 },

  234.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  235.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  236.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  237.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  238.     { 2,  0,  1, -1, -1, -1, -1, -1, -1 },

  239.     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },

  240.     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },

  241.     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },

  242.     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },

  243.     { 2,  3,  0,  1,  4,  5, -1, -1, -1 },

  244.     { 2,  0,  1,  3,  4,  5, -1, -1, -1 },

  245.     { 0,  5,  3,  4,  1,  2, -1, -1, -1 },

  246.     { 3,  2,  4,  0,  1,  5,  6, -1, -1 },

  247.     { 4,  5,  0,  1,  6,  2,  7,  3, -1 },

  248.     { 3,  2,  4,  0,  1,  5,  7,  6, -1 },

  249. };

  250. 

  251. static const int8_t dca_channel_reorder_nolfe_xch[][9] = {

  252.     { 0,  1, -1, -1, -1, -1, -1, -1, -1 },

  253.     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },

  254.     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },

  255.     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },

  256.     { 0,  1,  2, -1, -1, -1, -1, -1, -1 },

  257.     { 2,  0,  1,  3, -1, -1, -1, -1, -1 },

  258.     { 0,  1,  2,  3, -1, -1, -1, -1, -1 },

  259.     { 2,  0,  1,  3,  4, -1, -1, -1, -1 },

  260.     { 0,  1,  3,  4,  2, -1, -1, -1, -1 },

  261.     { 2,  0,  1,  4,  5,  3, -1, -1, -1 },

  262.     { 2,  3,  0,  1,  5,  6,  4, -1, -1 },

  263.     { 2,  0,  1,  3,  4,  5,  6, -1, -1 },

  264.     { 0,  5,  3,  4,  1,  2,  6, -1, -1 },

  265.     { 3,  2,  4,  0,  1,  6,  7,  5, -1 },

  266.     { 4,  5,  0,  1,  7,  2,  8,  3,  6 },

  267.     { 3,  2,  4,  0,  1,  5,  8,  7,  6 },

  268. };

  269. 

  270. #define DCA_DOLBY                  101           /* FIXME */

  271. 

  272. #define DCA_CHANNEL_BITS             6

  273. #define DCA_CHANNEL_MASK          0x3F

  274. 

  275. #define DCA_LFE                   0x80

  276. 

  277. #define HEADER_SIZE                 14

  278. 

  279. #define DCA_NSYNCAUX        0x9A1105A0

  280. 

  281. /** Bit allocation */

  282. typedef struct BitAlloc {

  283.     int offset;                 ///< code values offset

  284.     int maxbits[8];             ///< max bits in VLC

  285.     int wrap;                   ///< wrap for get_vlc2()

  286.     VLC vlc[8];                 ///< actual codes

  287. } BitAlloc;

  288. 

  289. static BitAlloc dca_bitalloc_index;    ///< indexes for samples VLC select

  290. static BitAlloc dca_tmode;             ///< transition mode VLCs

  291. static BitAlloc dca_scalefactor;       ///< scalefactor VLCs

  292. static BitAlloc dca_smpl_bitalloc[11]; ///< samples VLCs

  293. 

  294. static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,

  295.                                          int idx)

  296. {

  297.     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +

  298.            ba->offset;

  299. }

  300. 

  301. static float dca_dmix_code(unsigned code);

  302. 

  303. static const uint16_t dca_vlc_offs[] = {

  304.         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,

  305.      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,

  306.      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,

  307.      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,

  308.     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,

  309.     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,

  310. };

  311. 

  312. static av_cold void dca_init_vlcs(void)

  313. {

  314.     static int vlcs_initialized = 0;

  315.     int i, j, c = 14;

  316.     static VLC_TYPE dca_table[23622][2];

  317. 

  318.     if (vlcs_initialized)

  319.         return;

  320. 

  321.     dca_bitalloc_index.offset = 1;

  322.     dca_bitalloc_index.wrap   = 2;

  323.     for (i = 0; i < 5; i++) {

  324.         dca_bitalloc_index.vlc[i].table           = &dca_table[dca_vlc_offs[i]];

  325.         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];

  326.         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,

  327.                  bitalloc_12_bits[i], 1, 1,

  328.                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

  329.     }

  330.     dca_scalefactor.offset = -64;

  331.     dca_scalefactor.wrap   = 2;

  332.     for (i = 0; i < 5; i++) {

  333.         dca_scalefactor.vlc[i].table           = &dca_table[dca_vlc_offs[i + 5]];

  334.         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];

  335.         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,

  336.                  scales_bits[i], 1, 1,

  337.                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

  338.     }

  339.     dca_tmode.offset = 0;

  340.     dca_tmode.wrap   = 1;

  341.     for (i = 0; i < 4; i++) {

  342.         dca_tmode.vlc[i].table           = &dca_table[dca_vlc_offs[i + 10]];

  343.         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];

  344.         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,

  345.                  tmode_bits[i], 1, 1,

  346.                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);

  347.     }

  348. 

  349.     for (i = 0; i < 10; i++)

  350.         for (j = 0; j < 7; j++) {

  351.             if (!bitalloc_codes[i][j])

  352.                 break;

  353.             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];

  354.             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);

  355.             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];

  356.             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];

  357. 

  358.             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],

  359.                      bitalloc_sizes[i],

  360.                      bitalloc_bits[i][j], 1, 1,

  361.                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);

  362.             c++;

  363.         }

  364.     vlcs_initialized = 1;

  365. }

  366. 

  367. static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)

  368. {

  369.     while (len--)

  370.         *dst++ = get_bits(gb, bits);

  371. }

  372. 

  373. static inline int dca_xxch2index(DCAContext *s, int xxch_ch)

  374. {

  375.     int i, base, mask;

  376. 

  377.     /* locate channel set containing the channel */

  378.     for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);

  379.          i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])

  380.         base += av_popcount(mask);

  381. 

  382.     return base + av_popcount(mask & (xxch_ch - 1));

  383. }

  384. 

  385. static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,

  386.                                          int xxch)

  387. {

  388.     int i, j;

  389.     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };

  390.     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };

  391.     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };

  392.     int hdr_pos = 0, hdr_size = 0;

  393.     float scale_factor;

  394.     int this_chans, acc_mask;

  395.     int embedded_downmix;

  396.     int nchans, mask[8];

  397.     int coeff, ichan;

  398. 

  399.     /* xxch has arbitrary sized audio coding headers */

  400.     if (xxch) {

  401.         hdr_pos  = get_bits_count(&s->gb);

  402.         hdr_size = get_bits(&s->gb, 7) + 1;

  403.     }

  404. 

  405.     nchans = get_bits(&s->gb, 3) + 1;

  406.     s->total_channels = nchans + base_channel;

  407.     s->prim_channels  = s->total_channels;

  408. 

  409.     /* obtain speaker layout mask & downmix coefficients for XXCH */

  410.     if (xxch) {

  411.         acc_mask = s->xxch_core_spkmask;

  412. 

  413.         this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;

  414.         s->xxch_spk_masks[s->xxch_chset] = this_chans;

  415.         s->xxch_chset_nch[s->xxch_chset] = nchans;

  416. 

  417.         for (i = 0; i <= s->xxch_chset; i++)

  418.             acc_mask |= s->xxch_spk_masks[i];

  419. 

  420.         /* check for downmixing information */

  421.         if (get_bits1(&s->gb)) {

  422.             embedded_downmix = get_bits1(&s->gb);

  423.             coeff            = get_bits(&s->gb, 6);

  424. 

  425.             if (coeff<1 || coeff>61) {

  426.                 av_log(s->avctx, AV_LOG_ERROR, "6bit coeff %d is out of range\n", coeff);

  427.                 return AVERROR_INVALIDDATA;

  428.             }

  429. 

  430.             scale_factor     = -1.0f / dca_dmix_code((coeff<<2)-3);

  431. 

  432.             s->xxch_dmix_sf[s->xxch_chset] = scale_factor;

  433. 

  434.             for (i = base_channel; i < s->prim_channels; i++) {

  435.                 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);

  436.             }

  437. 

  438.             for (j = base_channel; j < s->prim_channels; j++) {

  439.                 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));

  440.                 s->xxch_dmix_embedded |= (embedded_downmix << j);

  441.                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {

  442.                     if (mask[j] & (1 << i)) {

  443.                         if ((1 << i) == DCA_XXCH_LFE1) {

  444.                             av_log(s->avctx, AV_LOG_WARNING,

  445.                                    "DCA-XXCH: dmix to LFE1 not supported.\n");

  446.                             continue;

  447.                         }

  448. 

  449.                         coeff = get_bits(&s->gb, 7);

  450.                         ichan = dca_xxch2index(s, 1 << i);

  451.                         if ((coeff&63)<1 || (coeff&63)>61) {

  452.                             av_log(s->avctx, AV_LOG_ERROR, "7bit coeff %d is out of range\n", coeff);

  453.                             return AVERROR_INVALIDDATA;

  454.                         }

  455.                         s->xxch_dmix_coeff[j][ichan] = dca_dmix_code((coeff<<2)-3);

  456.                     }

  457.                 }

  458.             }

  459.         }

  460.     }

  461. 

  462.     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)

  463.         s->prim_channels = DCA_PRIM_CHANNELS_MAX;

  464. 

  465.     for (i = base_channel; i < s->prim_channels; i++) {

  466.         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;

  467.         if (s->subband_activity[i] > DCA_SUBBANDS)

  468.             s->subband_activity[i] = DCA_SUBBANDS;

  469.     }

  470.     for (i = base_channel; i < s->prim_channels; i++) {

  471.         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;

  472.         if (s->vq_start_subband[i] > DCA_SUBBANDS)

  473.             s->vq_start_subband[i] = DCA_SUBBANDS;

  474.     }

  475.     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);

  476.     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);

  477.     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);

  478.     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);

  479. 

  480.     /* Get codebooks quantization indexes */

  481.     if (!base_channel)

  482.         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));

  483.     for (j = 1; j < 11; j++)

  484.         for (i = base_channel; i < s->prim_channels; i++)

  485.             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);

  486. 

  487.     /* Get scale factor adjustment */

  488.     for (j = 0; j < 11; j++)

  489.         for (i = base_channel; i < s->prim_channels; i++)

  490.             s->scalefactor_adj[i][j] = 1;

  491. 

  492.     for (j = 1; j < 11; j++)

  493.         for (i = base_channel; i < s->prim_channels; i++)

  494.             if (s->quant_index_huffman[i][j] < thr[j])

  495.                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];

  496. 

  497.     if (!xxch) {

  498.         if (s->crc_present) {

  499.             /* Audio header CRC check */

  500.             get_bits(&s->gb, 16);

  501.         }

  502.     } else {

  503.         /* Skip to the end of the header, also ignore CRC if present  */

  504.         i = get_bits_count(&s->gb);

  505.         if (hdr_pos + 8 * hdr_size > i)

  506.             skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);

  507.     }

  508. 

  509.     s->current_subframe    = 0;

  510.     s->current_subsubframe = 0;

  511. 

  512.     return 0;

  513. }

  514. 

  515. static int dca_parse_frame_header(DCAContext *s)

  516. {

  517.     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);

  518. 

  519.     /* Sync code */

  520.     skip_bits_long(&s->gb, 32);

  521. 

  522.     /* Frame header */

  523.     s->frame_type        = get_bits(&s->gb, 1);

  524.     s->samples_deficit   = get_bits(&s->gb, 5) + 1;

  525.     s->crc_present       = get_bits(&s->gb, 1);

  526.     s->sample_blocks     = get_bits(&s->gb, 7) + 1;

  527.     s->frame_size        = get_bits(&s->gb, 14) + 1;

  528.     if (s->frame_size < 95)

  529.         return AVERROR_INVALIDDATA;

  530.     s->amode             = get_bits(&s->gb, 6);

  531.     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];

  532.     if (!s->sample_rate)

  533.         return AVERROR_INVALIDDATA;

  534.     s->bit_rate_index    = get_bits(&s->gb, 5);

  535.     s->bit_rate          = dca_bit_rates[s->bit_rate_index];

  536.     if (!s->bit_rate)

  537.         return AVERROR_INVALIDDATA;

  538. 

  539.     skip_bits1(&s->gb); // always 0 (reserved, cf. ETSI TS 102 114 V1.4.1)

  540.     s->dynrange          = get_bits(&s->gb, 1);

  541.     s->timestamp         = get_bits(&s->gb, 1);

  542.     s->aux_data          = get_bits(&s->gb, 1);

  543.     s->hdcd              = get_bits(&s->gb, 1);

  544.     s->ext_descr         = get_bits(&s->gb, 3);

  545.     s->ext_coding        = get_bits(&s->gb, 1);

  546.     s->aspf              = get_bits(&s->gb, 1);

  547.     s->lfe               = get_bits(&s->gb, 2);

  548.     s->predictor_history = get_bits(&s->gb, 1);

  549. 

  550.     if (s->lfe > 2) {

  551.         s->lfe = 0;

  552.         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);

  553.         return AVERROR_INVALIDDATA;

  554.     }

  555. 

  556.     /* TODO: check CRC */

  557.     if (s->crc_present)

  558.         s->header_crc    = get_bits(&s->gb, 16);

  559. 

  560.     s->multirate_inter   = get_bits(&s->gb, 1);

  561.     s->version           = get_bits(&s->gb, 4);

  562.     s->copy_history      = get_bits(&s->gb, 2);

  563.     s->source_pcm_res    = get_bits(&s->gb, 3);

  564.     s->front_sum         = get_bits(&s->gb, 1);

  565.     s->surround_sum      = get_bits(&s->gb, 1);

  566.     s->dialog_norm       = get_bits(&s->gb, 4);

  567. 

  568.     /* FIXME: channels mixing levels */

  569.     s->output = s->amode;

  570.     if (s->lfe)

  571.         s->output |= DCA_LFE;

  572. 

  573.     /* Primary audio coding header */

  574.     s->subframes = get_bits(&s->gb, 4) + 1;

  575. 

  576.     return dca_parse_audio_coding_header(s, 0, 0);

  577. }

  578. 

  579. static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)

  580. {

  581.     if (level < 5) {

  582.         /* huffman encoded */

  583.         value += get_bitalloc(gb, &dca_scalefactor, level);

  584.         value  = av_clip(value, 0, (1 << log2range) - 1);

  585.     } else if (level < 8) {

  586.         if (level + 1 > log2range) {

  587.             skip_bits(gb, level + 1 - log2range);

  588.             value = get_bits(gb, log2range);

  589.         } else {

  590.             value = get_bits(gb, level + 1);

  591.         }

  592.     }

  593.     return value;

  594. }

  595. 

  596. static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)

  597. {

  598.     /* Primary audio coding side information */

  599.     int j, k;

  600. 

  601.     if (get_bits_left(&s->gb) < 0)

  602.         return AVERROR_INVALIDDATA;

  603. 

  604.     if (!base_channel) {

  605.         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;

  606.         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);

  607.     }

  608. 

  609.     for (j = base_channel; j < s->prim_channels; j++) {

  610.         for (k = 0; k < s->subband_activity[j]; k++)

  611.             s->prediction_mode[j][k] = get_bits(&s->gb, 1);

  612.     }

  613. 

  614.     /* Get prediction codebook */

  615.     for (j = base_channel; j < s->prim_channels; j++) {

  616.         for (k = 0; k < s->subband_activity[j]; k++) {

  617.             if (s->prediction_mode[j][k] > 0) {

  618.                 /* (Prediction coefficient VQ address) */

  619.                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);

  620.             }

  621.         }

  622.     }

  623. 

  624.     /* Bit allocation index */

  625.     for (j = base_channel; j < s->prim_channels; j++) {

  626.         for (k = 0; k < s->vq_start_subband[j]; k++) {

  627.             if (s->bitalloc_huffman[j] == 6)

  628.                 s->bitalloc[j][k] = get_bits(&s->gb, 5);

  629.             else if (s->bitalloc_huffman[j] == 5)

  630.                 s->bitalloc[j][k] = get_bits(&s->gb, 4);

  631.             else if (s->bitalloc_huffman[j] == 7) {

  632.                 av_log(s->avctx, AV_LOG_ERROR,

  633.                        "Invalid bit allocation index\n");

  634.                 return AVERROR_INVALIDDATA;

  635.             } else {

  636.                 s->bitalloc[j][k] =

  637.                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);

  638.             }

  639. 

  640.             if (s->bitalloc[j][k] > 26) {

  641.                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",

  642.                         j, k, s->bitalloc[j][k]);

  643.                 return AVERROR_INVALIDDATA;

  644.             }

  645.         }

  646.     }

  647. 

  648.     /* Transition mode */

  649.     for (j = base_channel; j < s->prim_channels; j++) {

  650.         for (k = 0; k < s->subband_activity[j]; k++) {

  651.             s->transition_mode[j][k] = 0;

  652.             if (s->subsubframes[s->current_subframe] > 1 &&

  653.                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {

  654.                 s->transition_mode[j][k] =

  655.                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);

  656.             }

  657.         }

  658.     }

  659. 

  660.     if (get_bits_left(&s->gb) < 0)

  661.         return AVERROR_INVALIDDATA;

  662. 

  663.     for (j = base_channel; j < s->prim_channels; j++) {

  664.         const uint32_t *scale_table;

  665.         int scale_sum, log_size;

  666. 

  667.         memset(s->scale_factor[j], 0,

  668.                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);

  669. 

  670.         if (s->scalefactor_huffman[j] == 6) {

  671.             scale_table = scale_factor_quant7;

  672.             log_size    = 7;

  673.         } else {

  674.             scale_table = scale_factor_quant6;

  675.             log_size    = 6;

  676.         }

  677. 

  678.         /* When huffman coded, only the difference is encoded */

  679.         scale_sum = 0;

  680. 

  681.         for (k = 0; k < s->subband_activity[j]; k++) {

  682.             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {

  683.                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);

  684.                 s->scale_factor[j][k][0] = scale_table[scale_sum];

  685.             }

  686. 

  687.             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {

  688.                 /* Get second scale factor */

  689.                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);

  690.                 s->scale_factor[j][k][1] = scale_table[scale_sum];

  691.             }

  692.         }

  693.     }

  694. 

  695.     /* Joint subband scale factor codebook select */

  696.     for (j = base_channel; j < s->prim_channels; j++) {

  697.         /* Transmitted only if joint subband coding enabled */

  698.         if (s->joint_intensity[j] > 0)

  699.             s->joint_huff[j] = get_bits(&s->gb, 3);

  700.     }

  701. 

  702.     if (get_bits_left(&s->gb) < 0)

  703.         return AVERROR_INVALIDDATA;

  704. 

  705.     /* Scale factors for joint subband coding */

  706.     for (j = base_channel; j < s->prim_channels; j++) {

  707.         int source_channel;

  708. 

  709.         /* Transmitted only if joint subband coding enabled */

  710.         if (s->joint_intensity[j] > 0) {

  711.             int scale = 0;

  712.             source_channel = s->joint_intensity[j] - 1;

  713. 

  714.             /* When huffman coded, only the difference is encoded

  715.              * (is this valid as well for joint scales ???) */

  716. 

  717.             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {

  718.                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);

  719.                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */

  720.             }

  721. 

  722.             if (!(s->debug_flag & 0x02)) {

  723.                 av_log(s->avctx, AV_LOG_DEBUG,

  724.                        "Joint stereo coding not supported\n");

  725.                 s->debug_flag |= 0x02;

  726.             }

  727.         }

  728.     }

  729. 

  730.     /* Dynamic range coefficient */

  731.     if (!base_channel && s->dynrange)

  732.         s->dynrange_coef = get_bits(&s->gb, 8);

  733. 

  734.     /* Side information CRC check word */

  735.     if (s->crc_present) {

  736.         get_bits(&s->gb, 16);

  737.     }

  738. 

  739.     /*

  740.      * Primary audio data arrays

  741.      */

  742. 

  743.     /* VQ encoded high frequency subbands */

  744.     for (j = base_channel; j < s->prim_channels; j++)

  745.         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)

  746.             /* 1 vector -> 32 samples */

  747.             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);

  748. 

  749.     /* Low frequency effect data */

  750.     if (!base_channel && s->lfe) {

  751.         int quant7;

  752.         /* LFE samples */

  753.         int lfe_samples    = 2 * s->lfe * (4 + block_index);

  754.         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);

  755.         float lfe_scale;

  756. 

  757.         for (j = lfe_samples; j < lfe_end_sample; j++) {

  758.             /* Signed 8 bits int */

  759.             s->lfe_data[j] = get_sbits(&s->gb, 8);

  760.         }

  761. 

  762.         /* Scale factor index */

  763.         quant7 = get_bits(&s->gb, 8);

  764.         if (quant7 > 127) {

  765.             avpriv_request_sample(s->avctx, "LFEScaleIndex larger than 127");

  766.             return AVERROR_INVALIDDATA;

  767.         }

  768.         s->lfe_scale_factor = scale_factor_quant7[quant7];

  769. 

  770.         /* Quantization step size * scale factor */

  771.         lfe_scale = 0.035 * s->lfe_scale_factor;

  772. 

  773.         for (j = lfe_samples; j < lfe_end_sample; j++)

  774.             s->lfe_data[j] *= lfe_scale;

  775.     }

  776. 

  777.     return 0;

  778. }

  779. 

  780. static void qmf_32_subbands(DCAContext *s, int chans,

  781.                             float samples_in[32][8], float *samples_out,

  782.                             float scale)

  783. {

  784.     const float *prCoeff;

  785. 

  786.     int sb_act = s->subband_activity[chans];

  787. 

  788.     scale *= sqrt(1 / 8.0);

  789. 

  790.     /* Select filter */

  791.     if (!s->multirate_inter)    /* Non-perfect reconstruction */

  792.         prCoeff = fir_32bands_nonperfect;

  793.     else                        /* Perfect reconstruction */

  794.         prCoeff = fir_32bands_perfect;

  795. 

  796.     s->dcadsp.qmf_32_subbands(samples_in, sb_act, &s->synth, &s->imdct,

  797.                               s->subband_fir_hist[chans],

  798.                               &s->hist_index[chans],

  799.                               s->subband_fir_noidea[chans], prCoeff,

  800.                               samples_out, s->raXin, scale);

  801. }

  802. 

  803. static void lfe_interpolation_fir(DCAContext *s, int decimation_select,

  804.                                   int num_deci_sample, float *samples_in,

  805.                                   float *samples_out)

  806. {

  807.     /* samples_in: An array holding decimated samples.

  808.      *   Samples in current subframe starts from samples_in[0],

  809.      *   while samples_in[-1], samples_in[-2], ..., stores samples

  810.      *   from last subframe as history.

  811.      *

  812.      * samples_out: An array holding interpolated samples

  813.      */

  814. 

  815.     int idx;

  816.     const float *prCoeff;

  817.     int deciindex;

  818. 

  819.     /* Select decimation filter */

  820.     if (decimation_select == 1) {

  821.         idx     = 1;

  822.         prCoeff = lfe_fir_128;

  823.     } else {

  824.         idx     = 0;

  825.         prCoeff = lfe_fir_64;

  826.     }

  827.     /* Interpolation */

  828.     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {

  829.         s->dcadsp.lfe_fir[idx](samples_out, samples_in, prCoeff);

  830.         samples_in++;

  831.         samples_out += 2 * 32 * (1 + idx);

  832.     }

  833. }

  834. 

  835. /* downmixing routines */

  836. #define MIX_REAR1(samples, s1, rs, coef)            \

  837.     samples[0][i] += samples[s1][i] * coef[rs][0];  \

  838.     samples[1][i] += samples[s1][i] * coef[rs][1];

  839. 

  840. #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \

  841.     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \

  842.     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];

  843. 

  844. #define MIX_FRONT3(samples, coef)                                      \

  845.     t = samples[c][i];                                                 \

  846.     u = samples[l][i];                                                 \

  847.     v = samples[r][i];                                                 \

  848.     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \

  849.     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];

  850. 

  851. #define DOWNMIX_TO_STEREO(op1, op2)             \

  852.     for (i = 0; i < 256; i++) {                 \

  853.         op1                                     \

  854.         op2                                     \

  855.     }

  856. 

  857. static void dca_downmix(float **samples, int srcfmt, int lfe_present,

  858.                         float coef[DCA_PRIM_CHANNELS_MAX + 1][2],

  859.                         const int8_t *channel_mapping)

  860. {

  861.     int c, l, r, sl, sr, s;

  862.     int i;

  863.     float t, u, v;

  864. 

  865.     switch (srcfmt) {

  866.     case DCA_MONO:

  867.     case DCA_4F2R:

  868.         av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");

  869.         break;

  870.     case DCA_CHANNEL:

  871.     case DCA_STEREO:

  872.     case DCA_STEREO_TOTAL:

  873.     case DCA_STEREO_SUMDIFF:

  874.         break;

  875.     case DCA_3F:

  876.         c = channel_mapping[0];

  877.         l = channel_mapping[1];

  878.         r = channel_mapping[2];

  879.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );

  880.         break;

  881.     case DCA_2F1R:

  882.         s = channel_mapping[2];

  883.         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );

  884.         break;

  885.     case DCA_3F1R:

  886.         c = channel_mapping[0];

  887.         l = channel_mapping[1];

  888.         r = channel_mapping[2];

  889.         s = channel_mapping[3];

  890.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

  891.                           MIX_REAR1(samples, s, 3, coef));

  892.         break;

  893.     case DCA_2F2R:

  894.         sl = channel_mapping[2];

  895.         sr = channel_mapping[3];

  896.         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );

  897.         break;

  898.     case DCA_3F2R:

  899.         c  = channel_mapping[0];

  900.         l  = channel_mapping[1];

  901.         r  = channel_mapping[2];

  902.         sl = channel_mapping[3];

  903.         sr = channel_mapping[4];

  904.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

  905.                           MIX_REAR2(samples, sl, sr, 3, coef));

  906.         break;

  907.     }

  908.     if (lfe_present) {

  909.         int lf_buf = dca_lfe_index[srcfmt];

  910.         int lf_idx =  dca_channels[srcfmt];

  911.         for (i = 0; i < 256; i++) {

  912.             samples[0][i] += samples[lf_buf][i] * coef[lf_idx][0];

  913.             samples[1][i] += samples[lf_buf][i] * coef[lf_idx][1];

  914.         }

  915.     }

  916. }

  917. 

  918. #ifndef decode_blockcodes

  919. /* Very compact version of the block code decoder that does not use table

  920.  * look-up but is slightly slower */

  921. static int decode_blockcode(int code, int levels, int32_t *values)

  922. {

  923.     int i;

  924.     int offset = (levels - 1) >> 1;

  925. 

  926.     for (i = 0; i < 4; i++) {

  927.         int div = FASTDIV(code, levels);

  928.         values[i] = code - offset - div * levels;

  929.         code      = div;

  930.     }

  931. 

  932.     return code;

  933. }

  934. 

  935. static int decode_blockcodes(int code1, int code2, int levels, int32_t *values)

  936. {

  937.     return decode_blockcode(code1, levels, values) |

  938.            decode_blockcode(code2, levels, values + 4);

  939. }

  940. #endif

  941. 

  942. static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };

  943. static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };

  944. 

  945. static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)

  946. {

  947.     int k, l;

  948.     int subsubframe = s->current_subsubframe;

  949. 

  950.     const float *quant_step_table;

  951. 

  952.     /* FIXME */

  953.     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];

  954.     LOCAL_ALIGNED_16(int32_t, block, [8 * DCA_SUBBANDS]);

  955. 

  956.     /*

  957.      * Audio data

  958.      */

  959. 

  960.     /* Select quantization step size table */

  961.     if (s->bit_rate_index == 0x1f)

  962.         quant_step_table = lossless_quant_d;

  963.     else

  964.         quant_step_table = lossy_quant_d;

  965. 

  966.     for (k = base_channel; k < s->prim_channels; k++) {

  967.         float rscale[DCA_SUBBANDS];

  968. 

  969.         if (get_bits_left(&s->gb) < 0)

  970.             return AVERROR_INVALIDDATA;

  971. 

  972.         for (l = 0; l < s->vq_start_subband[k]; l++) {

  973.             int m;

  974. 

  975.             /* Select the mid-tread linear quantizer */

  976.             int abits = s->bitalloc[k][l];

  977. 

  978.             float quant_step_size = quant_step_table[abits];

  979. 

  980.             /*

  981.              * Determine quantization index code book and its type

  982.              */

  983. 

  984.             /* Select quantization index code book */

  985.             int sel = s->quant_index_huffman[k][abits];

  986. 

  987.             /*

  988.              * Extract bits from the bit stream

  989.              */

  990.             if (!abits) {

  991.                 rscale[l] = 0;

  992.                 memset(block + 8 * l, 0, 8 * sizeof(block[0]));

  993.             } else {

  994.                 /* Deal with transients */

  995.                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];

  996.                 rscale[l] = quant_step_size * s->scale_factor[k][l][sfi] *

  997.                             s->scalefactor_adj[k][sel];

  998. 

  999.                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {

  1000.                     if (abits <= 7) {

  1001.                         /* Block code */

  1002.                         int block_code1, block_code2, size, levels, err;

  1003. 

  1004.                         size   = abits_sizes[abits - 1];

  1005.                         levels = abits_levels[abits - 1];

  1006. 

  1007.                         block_code1 = get_bits(&s->gb, size);

  1008.                         block_code2 = get_bits(&s->gb, size);

  1009.                         err         = decode_blockcodes(block_code1, block_code2,

  1010.                                                         levels, block + 8 * l);

  1011.                         if (err) {

  1012.                             av_log(s->avctx, AV_LOG_ERROR,

  1013.                                    "ERROR: block code look-up failed\n");

  1014.                             return AVERROR_INVALIDDATA;

  1015.                         }

  1016.                     } else {

  1017.                         /* no coding */

  1018.                         for (m = 0; m < 8; m++)

  1019.                             block[8 * l + m] = get_sbits(&s->gb, abits - 3);

  1020.                     }

  1021.                 } else {

  1022.                     /* Huffman coded */

  1023.                     for (m = 0; m < 8; m++)

  1024.                         block[8 * l + m] = get_bitalloc(&s->gb,

  1025.                                                         &dca_smpl_bitalloc[abits], sel);

  1026.                 }

  1027.             }

  1028.         }

  1029. 

  1030.         s->fmt_conv.int32_to_float_fmul_array8(&s->fmt_conv, subband_samples[k][0],

  1031.                                                block, rscale, 8 * s->vq_start_subband[k]);

  1032. 

  1033.         for (l = 0; l < s->vq_start_subband[k]; l++) {

  1034.             int m;

  1035.             /*

  1036.              * Inverse ADPCM if in prediction mode

  1037.              */

  1038.             if (s->prediction_mode[k][l]) {

  1039.                 int n;

  1040.                 if (s->predictor_history)

  1041.                     subband_samples[k][l][0] += (adpcm_vb[s->prediction_vq[k][l]][0] *

  1042.                                                  s->subband_samples_hist[k][l][3] +

  1043.                                                  adpcm_vb[s->prediction_vq[k][l]][1] *

  1044.                                                  s->subband_samples_hist[k][l][2] +

  1045.                                                  adpcm_vb[s->prediction_vq[k][l]][2] *

  1046.                                                  s->subband_samples_hist[k][l][1] +

  1047.                                                  adpcm_vb[s->prediction_vq[k][l]][3] *

  1048.                                                  s->subband_samples_hist[k][l][0]) *

  1049.                                                 (1.0f / 8192);

  1050.                 for (m = 1; m < 8; m++) {

  1051.                     float sum = adpcm_vb[s->prediction_vq[k][l]][0] *

  1052.                                 subband_samples[k][l][m - 1];

  1053.                     for (n = 2; n <= 4; n++)

  1054.                         if (m >= n)

  1055.                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *

  1056.                                    subband_samples[k][l][m - n];

  1057.                         else if (s->predictor_history)

  1058.                             sum += adpcm_vb[s->prediction_vq[k][l]][n - 1] *

  1059.                                    s->subband_samples_hist[k][l][m - n + 4];

  1060.                     subband_samples[k][l][m] += sum * (1.0f / 8192);

  1061.                 }

  1062.             }

  1063.         }

  1064. 

  1065.         /*

  1066.          * Decode VQ encoded high frequencies

  1067.          */

  1068.         if (s->subband_activity[k] > s->vq_start_subband[k]) {

  1069.             if (!(s->debug_flag & 0x01)) {

  1070.                 av_log(s->avctx, AV_LOG_DEBUG,

  1071.                        "Stream with high frequencies VQ coding\n");

  1072.                 s->debug_flag |= 0x01;

  1073.             }

  1074.             s->dcadsp.decode_hf(subband_samples[k], s->high_freq_vq[k],

  1075.                                 high_freq_vq, subsubframe * 8,

  1076.                                 s->scale_factor[k], s->vq_start_subband[k],

  1077.                                 s->subband_activity[k]);

  1078.         }

  1079.     }

  1080. 

  1081.     /* Check for DSYNC after subsubframe */

  1082.     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {

  1083.         if (get_bits(&s->gb, 16) != 0xFFFF) {

  1084.             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");

  1085.             return AVERROR_INVALIDDATA;

  1086.         }

  1087.     }

  1088. 

  1089.     /* Backup predictor history for adpcm */

  1090.     for (k = base_channel; k < s->prim_channels; k++)

  1091.         for (l = 0; l < s->vq_start_subband[k]; l++)

  1092.             AV_COPY128(s->subband_samples_hist[k][l], &subband_samples[k][l][4]);

  1093. 

  1094.     return 0;

  1095. }

  1096. 

  1097. static int dca_filter_channels(DCAContext *s, int block_index)

  1098. {

  1099.     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];

  1100.     int k;

  1101. 

  1102.     /* 32 subbands QMF */

  1103.     for (k = 0; k < s->prim_channels; k++) {

  1104.         if (s->channel_order_tab[k] >= 0)

  1105.             qmf_32_subbands(s, k, subband_samples[k],

  1106.                             s->samples_chanptr[s->channel_order_tab[k]],

  1107.                             M_SQRT1_2 / 32768.0);

  1108.     }

  1109. 

  1110.     /* Generate LFE samples for this subsubframe FIXME!!! */

  1111.     if (s->lfe) {

  1112.         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,

  1113.                               s->lfe_data + 2 * s->lfe * (block_index + 4),

  1114.                               s->samples_chanptr[s->lfe_index]);

  1115.         /* Outputs 20bits pcm samples */

  1116.     }

  1117. 

  1118.     /* Downmixing to Stereo */

  1119.     if (s->prim_channels + !!s->lfe > 2 &&

  1120.         s->avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {

  1121.         dca_downmix(s->samples_chanptr, s->amode, !!s->lfe, s->downmix_coef,

  1122.                     s->channel_order_tab);

  1123.     }

  1124. 

  1125.     return 0;

  1126. }

  1127. 

  1128. static int dca_subframe_footer(DCAContext *s, int base_channel)

  1129. {

  1130.     int in, out, aux_data_count, aux_data_end, reserved;

  1131.     uint32_t nsyncaux;

  1132. 

  1133.     /*

  1134.      * Unpack optional information

  1135.      */

  1136. 

  1137.     /* presumably optional information only appears in the core? */

  1138.     if (!base_channel) {

  1139.         if (s->timestamp)

  1140.             skip_bits_long(&s->gb, 32);

  1141. 

  1142.         if (s->aux_data) {

  1143.             aux_data_count = get_bits(&s->gb, 6);

  1144. 

  1145.             // align (32-bit)

  1146.             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);

  1147. 

  1148.             aux_data_end = 8 * aux_data_count + get_bits_count(&s->gb);

  1149. 

  1150.             if ((nsyncaux = get_bits_long(&s->gb, 32)) != DCA_NSYNCAUX) {

  1151.                 av_log(s->avctx, AV_LOG_ERROR, "nSYNCAUX mismatch %#"PRIx32"\n",

  1152.                        nsyncaux);

  1153.                 return AVERROR_INVALIDDATA;

  1154.             }

  1155. 

  1156.             if (get_bits1(&s->gb)) { // bAUXTimeStampFlag

  1157.                 avpriv_request_sample(s->avctx,

  1158.                                       "Auxiliary Decode Time Stamp Flag");

  1159.                 // align (4-bit)

  1160.                 skip_bits(&s->gb, (-get_bits_count(&s->gb)) & 4);

  1161.                 // 44 bits: nMSByte (8), nMarker (4), nLSByte (28), nMarker (4)

  1162.                 skip_bits_long(&s->gb, 44);

  1163.             }

  1164. 

  1165.             if ((s->core_downmix = get_bits1(&s->gb))) {

  1166.                 int am = get_bits(&s->gb, 3);

  1167.                 switch (am) {

  1168.                 case 0:

  1169.                     s->core_downmix_amode = DCA_MONO;

  1170.                     break;

  1171.                 case 1:

  1172.                     s->core_downmix_amode = DCA_STEREO;

  1173.                     break;

  1174.                 case 2:

  1175.                     s->core_downmix_amode = DCA_STEREO_TOTAL;

  1176.                     break;

  1177.                 case 3:

  1178.                     s->core_downmix_amode = DCA_3F;

  1179.                     break;

  1180.                 case 4:

  1181.                     s->core_downmix_amode = DCA_2F1R;

  1182.                     break;

  1183.                 case 5:

  1184.                     s->core_downmix_amode = DCA_2F2R;

  1185.                     break;

  1186.                 case 6:

  1187.                     s->core_downmix_amode = DCA_3F1R;

  1188.                     break;

  1189.                 default:

  1190.                     av_log(s->avctx, AV_LOG_ERROR,

  1191.                            "Invalid mode %d for embedded downmix coefficients\n",

  1192.                            am);

  1193.                     return AVERROR_INVALIDDATA;

  1194.                 }

  1195.                 for (out = 0; out < dca_channels[s->core_downmix_amode]; out++) {

  1196.                     for (in = 0; in < s->prim_channels + !!s->lfe; in++) {

  1197.                         uint16_t tmp = get_bits(&s->gb, 9);

  1198.                         if ((tmp & 0xFF) > 241) {

  1199.                             av_log(s->avctx, AV_LOG_ERROR,

  1200.                                    "Invalid downmix coefficient code %"PRIu16"\n",

  1201.                                    tmp);

  1202.                             return AVERROR_INVALIDDATA;

  1203.                         }

  1204.                         s->core_downmix_codes[in][out] = tmp;

  1205.                     }

  1206.                 }

  1207.             }

  1208. 

  1209.             align_get_bits(&s->gb); // byte align

  1210.             skip_bits(&s->gb, 16);  // nAUXCRC16

  1211. 

  1212.             // additional data (reserved, cf. ETSI TS 102 114 V1.4.1)

  1213.             if ((reserved = (aux_data_end - get_bits_count(&s->gb))) < 0) {

  1214.                 av_log(s->avctx, AV_LOG_ERROR,

  1215.                        "Overread auxiliary data by %d bits\n", -reserved);

  1216.                 return AVERROR_INVALIDDATA;

  1217.             } else if (reserved) {

  1218.                 avpriv_request_sample(s->avctx,

  1219.                                       "Core auxiliary data reserved content");

  1220.                 skip_bits_long(&s->gb, reserved);

  1221.             }

  1222.         }

  1223. 

  1224.         if (s->crc_present && s->dynrange)

  1225.             get_bits(&s->gb, 16);

  1226.     }

  1227. 

  1228.     return 0;

  1229. }

  1230. 

  1231. /**

  1232.  * Decode a dca frame block

  1233.  *

  1234.  * @param s     pointer to the DCAContext

  1235.  */

  1236. 

  1237. static int dca_decode_block(DCAContext *s, int base_channel, int block_index)

  1238. {

  1239.     int ret;

  1240. 

  1241.     /* Sanity check */

  1242.     if (s->current_subframe >= s->subframes) {

  1243.         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",

  1244.                s->current_subframe, s->subframes);

  1245.         return AVERROR_INVALIDDATA;

  1246.     }

  1247. 

  1248.     if (!s->current_subsubframe) {

  1249.         /* Read subframe header */

  1250.         if ((ret = dca_subframe_header(s, base_channel, block_index)))

  1251.             return ret;

  1252.     }

  1253. 

  1254.     /* Read subsubframe */

  1255.     if ((ret = dca_subsubframe(s, base_channel, block_index)))

  1256.         return ret;

  1257. 

  1258.     /* Update state */

  1259.     s->current_subsubframe++;

  1260.     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {

  1261.         s->current_subsubframe = 0;

  1262.         s->current_subframe++;

  1263.     }

  1264.     if (s->current_subframe >= s->subframes) {

  1265.         /* Read subframe footer */

  1266.         if ((ret = dca_subframe_footer(s, base_channel)))

  1267.             return ret;

  1268.     }

  1269. 

  1270.     return 0;

  1271. }

  1272. 

  1273. int ff_dca_xbr_parse_frame(DCAContext *s)

  1274. {

  1275.     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];

  1276.     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];

  1277.     int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];

  1278.     int anctemp[DCA_CHSET_CHANS_MAX];

  1279.     int chset_fsize[DCA_CHSETS_MAX];

  1280.     int n_xbr_ch[DCA_CHSETS_MAX];

  1281.     int hdr_size, num_chsets, xbr_tmode, hdr_pos;

  1282.     int i, j, k, l, chset, chan_base;

  1283. 

  1284.     av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");

  1285. 

  1286.     /* get bit position of sync header */

  1287.     hdr_pos = get_bits_count(&s->gb) - 32;

  1288. 

  1289.     hdr_size = get_bits(&s->gb, 6) + 1;

  1290.     num_chsets = get_bits(&s->gb, 2) + 1;

  1291. 

  1292.     for(i = 0; i < num_chsets; i++)

  1293.         chset_fsize[i] = get_bits(&s->gb, 14) + 1;

  1294. 

  1295.     xbr_tmode = get_bits1(&s->gb);

  1296. 

  1297.     for(i = 0; i < num_chsets; i++) {

  1298.         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;

  1299.         k = get_bits(&s->gb, 2) + 5;

  1300.         for(j = 0; j < n_xbr_ch[i]; j++)

  1301.             active_bands[i][j] = get_bits(&s->gb, k) + 1;

  1302.     }

  1303. 

  1304.     /* skip to the end of the header */

  1305.     i = get_bits_count(&s->gb);

  1306.     if(hdr_pos + hdr_size * 8 > i)

  1307.         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);

  1308. 

  1309.     /* loop over the channel data sets */

  1310.     /* only decode as many channels as we've decoded base data for */

  1311.     for(chset = 0, chan_base = 0;

  1312.         chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;

  1313.         chan_base += n_xbr_ch[chset++]) {

  1314.         int start_posn = get_bits_count(&s->gb);

  1315.         int subsubframe = 0;

  1316.         int subframe = 0;

  1317. 

  1318.         /* loop over subframes */

  1319.         for (k = 0; k < (s->sample_blocks / 8); k++) {

  1320.             /* parse header if we're on first subsubframe of a block */

  1321.             if(subsubframe == 0) {

  1322.                 /* Parse subframe header */

  1323.                 for(i = 0; i < n_xbr_ch[chset]; i++) {

  1324.                     anctemp[i] = get_bits(&s->gb, 2) + 2;

  1325.                 }

  1326. 

  1327.                 for(i = 0; i < n_xbr_ch[chset]; i++) {

  1328.                     get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);

  1329.                 }

  1330. 

  1331.                 for(i = 0; i < n_xbr_ch[chset]; i++) {

  1332.                     anctemp[i] = get_bits(&s->gb, 3);

  1333.                     if(anctemp[i] < 1) {

  1334.                         av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");

  1335.                         return AVERROR_INVALIDDATA;

  1336.                     }

  1337.                 }

  1338. 

  1339.                 /* generate scale factors */

  1340.                 for(i = 0; i < n_xbr_ch[chset]; i++) {

  1341.                     const uint32_t *scale_table;

  1342.                     int nbits;

  1343. 

  1344.                     if (s->scalefactor_huffman[chan_base+i] == 6) {

  1345.                         scale_table = scale_factor_quant7;

  1346.                     } else {

  1347.                         scale_table = scale_factor_quant6;

  1348.                     }

  1349. 

  1350.                     nbits = anctemp[i];

  1351. 

  1352.                     for(j = 0; j < active_bands[chset][i]; j++) {

  1353.                         if(abits_high[i][j] > 0) {

  1354.                             scale_table_high[i][j][0] =

  1355.                                 scale_table[get_bits(&s->gb, nbits)];

  1356. 

  1357.                             if(xbr_tmode && s->transition_mode[i][j]) {

  1358.                                 scale_table_high[i][j][1] =

  1359.                                     scale_table[get_bits(&s->gb, nbits)];

  1360.                             }

  1361.                         }

  1362.                     }

  1363.                 }

  1364.             }

  1365. 

  1366.             /* decode audio array for this block */

  1367.             for(i = 0; i < n_xbr_ch[chset]; i++) {

  1368.                 for(j = 0; j < active_bands[chset][i]; j++) {

  1369.                     const int xbr_abits = abits_high[i][j];

  1370.                     const float quant_step_size = lossless_quant_d[xbr_abits];

  1371.                     const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];

  1372.                     const float rscale = quant_step_size * scale_table_high[i][j][sfi];

  1373.                     float *subband_samples = s->subband_samples[k][chan_base+i][j];

  1374.                     int block[8];

  1375. 

  1376.                     if(xbr_abits <= 0)

  1377.                         continue;

  1378. 

  1379.                     if(xbr_abits > 7) {

  1380.                         get_array(&s->gb, block, 8, xbr_abits - 3);

  1381.                     } else {

  1382.                         int block_code1, block_code2, size, levels, err;

  1383. 

  1384.                         size   = abits_sizes[xbr_abits - 1];

  1385.                         levels = abits_levels[xbr_abits - 1];

  1386. 

  1387.                         block_code1 = get_bits(&s->gb, size);

  1388.                         block_code2 = get_bits(&s->gb, size);

  1389.                         err = decode_blockcodes(block_code1, block_code2,

  1390.                                                 levels, block);

  1391.                         if (err) {

  1392.                             av_log(s->avctx, AV_LOG_ERROR,

  1393.                                    "ERROR: DTS-XBR: block code look-up failed\n");

  1394.                             return AVERROR_INVALIDDATA;

  1395.                         }

  1396.                     }

  1397. 

  1398.                     /* scale & sum into subband */

  1399.                     for(l = 0; l < 8; l++)

  1400.                         subband_samples[l] += (float)block[l] * rscale;

  1401.                 }

  1402.             }

  1403. 

  1404.             /* check DSYNC marker */

  1405.             if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {

  1406.                 if(get_bits(&s->gb, 16) != 0xffff) {

  1407.                     av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");

  1408.                     return AVERROR_INVALIDDATA;

  1409.                 }

  1410.             }

  1411. 

  1412.             /* advance sub-sub-frame index */

  1413.             if(++subsubframe >= s->subsubframes[subframe]) {

  1414.                 subsubframe = 0;

  1415.                 subframe++;

  1416.             }

  1417.         }

  1418. 

  1419.         /* skip to next channel set */

  1420.         i = get_bits_count(&s->gb);

  1421.         if(start_posn + chset_fsize[chset] * 8 != i) {

  1422.             j = start_posn + chset_fsize[chset] * 8 - i;

  1423.             if(j < 0 || j >= 8)

  1424.                 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"

  1425.                        " skipping further than expected (%d bits)\n", j);

  1426.             skip_bits_long(&s->gb, j);

  1427.         }

  1428.     }

  1429. 

  1430.     return 0;

  1431. }

  1432. 

  1433. 

  1434. /* parse initial header for XXCH and dump details */

  1435. int ff_dca_xxch_decode_frame(DCAContext *s)

  1436. {

  1437.     int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;

  1438.     int i, chset, base_channel, chstart, fsize[8];

  1439. 

  1440.     /* assume header word has already been parsed */

  1441.     hdr_pos     = get_bits_count(&s->gb) - 32;

  1442.     hdr_size    = get_bits(&s->gb, 6) + 1;

  1443.   /*chhdr_crc   =*/ skip_bits1(&s->gb);

  1444.     spkmsk_bits = get_bits(&s->gb, 5) + 1;

  1445.     num_chsets  = get_bits(&s->gb, 2) + 1;

  1446. 

  1447.     for (i = 0; i < num_chsets; i++)

  1448.         fsize[i] = get_bits(&s->gb, 14) + 1;

  1449. 

  1450.     core_spk               = get_bits(&s->gb, spkmsk_bits);

  1451.     s->xxch_core_spkmask   = core_spk;

  1452.     s->xxch_nbits_spk_mask = spkmsk_bits;

  1453.     s->xxch_dmix_embedded  = 0;

  1454. 

  1455.     /* skip to the end of the header */

  1456.     i = get_bits_count(&s->gb);

  1457.     if (hdr_pos + hdr_size * 8 > i)

  1458.         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);

  1459. 

  1460.     for (chset = 0; chset < num_chsets; chset++) {

  1461.         chstart       = get_bits_count(&s->gb);

  1462.         base_channel  = s->prim_channels;

  1463.         s->xxch_chset = chset;

  1464. 

  1465.         /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.

  1466.            5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */

  1467.         dca_parse_audio_coding_header(s, base_channel, 1);

  1468. 

  1469.         /* decode channel data */

  1470.         for (i = 0; i < (s->sample_blocks / 8); i++) {

  1471.             if (dca_decode_block(s, base_channel, i)) {

  1472.                 av_log(s->avctx, AV_LOG_ERROR,

  1473.                        "Error decoding DTS-XXCH extension\n");

  1474.                 continue;

  1475.             }

  1476.         }

  1477. 

  1478.         /* skip to end of this section */

  1479.         i = get_bits_count(&s->gb);

  1480.         if (chstart + fsize[chset] * 8 > i)

  1481.             skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);

  1482.     }

  1483.     s->xxch_chset = num_chsets;

  1484. 

  1485.     return 0;

  1486. }

  1487. 

  1488. static float dca_dmix_code(unsigned code)

  1489. {

  1490.     int sign = (code >> 8) - 1;

  1491.     code &= 0xff;

  1492.     return ((dca_dmixtable[code] ^ sign) - sign) * (1.0 / (1 << 15));

  1493. }

  1494. 

  1495. /**

  1496.  * Main frame decoding function

  1497.  * FIXME add arguments

  1498.  */

  1499. static int dca_decode_frame(AVCodecContext *avctx, void *data,

  1500.                             int *got_frame_ptr, AVPacket *avpkt)

  1501. {

  1502.     AVFrame *frame     = data;

  1503.     const uint8_t *buf = avpkt->data;

  1504.     int buf_size       = avpkt->size;

  1505.     int channel_mask;

  1506.     int channel_layout;

  1507.     int lfe_samples;

  1508.     int num_core_channels = 0;

  1509.     int i, ret;

  1510.     float **samples_flt;

  1511.     float *src_chan;

  1512.     float *dst_chan;

  1513.     DCAContext *s = avctx->priv_data;

  1514.     int core_ss_end;

  1515.     int channels, full_channels;

  1516.     float scale;

  1517.     int achan;

  1518.     int chset;

  1519.     int mask;

  1520.     int lavc;

  1521.     int posn;

  1522.     int j, k;

  1523.     int endch;

  1524. 

  1525.     s->xch_present = 0;

  1526. 

  1527.     s->dca_buffer_size = avpriv_dca_convert_bitstream(buf, buf_size, s->dca_buffer,

  1528.                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);

  1529.     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {

  1530.         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");

  1531.         return AVERROR_INVALIDDATA;

  1532.     }

  1533. 

  1534.     if ((ret = dca_parse_frame_header(s)) < 0) {

  1535.         // seems like the frame is corrupt, try with the next one

  1536.         return ret;

  1537.     }

  1538.     // set AVCodec values with parsed data

  1539.     avctx->sample_rate = s->sample_rate;

  1540.     avctx->bit_rate    = s->bit_rate;

  1541. 

  1542.     s->profile = FF_PROFILE_DTS;

  1543. 

  1544.     for (i = 0; i < (s->sample_blocks / 8); i++) {

  1545.         if ((ret = dca_decode_block(s, 0, i))) {

  1546.             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");

  1547.             return ret;

  1548.         }

  1549.     }

  1550. 

  1551.     /* record number of core channels incase less than max channels are requested */

  1552.     num_core_channels = s->prim_channels;

  1553. 

  1554.     if (s->prim_channels + !!s->lfe > 2 &&

  1555.         avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {

  1556.             /* Stereo downmix coefficients

  1557.              *

  1558.              * The decoder can only downmix to 2-channel, so we need to ensure

  1559.              * embedded downmix coefficients are actually targeting 2-channel.

  1560.              */

  1561.             if (s->core_downmix && (s->core_downmix_amode == DCA_STEREO ||

  1562.                                     s->core_downmix_amode == DCA_STEREO_TOTAL)) {

  1563.                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {

  1564.                     /* Range checked earlier */

  1565.                     s->downmix_coef[i][0] = dca_dmix_code(s->core_downmix_codes[i][0]);

  1566.                     s->downmix_coef[i][1] = dca_dmix_code(s->core_downmix_codes[i][1]);

  1567.                 }

  1568.                 s->output = s->core_downmix_amode;

  1569.             } else {

  1570.                 int am = s->amode & DCA_CHANNEL_MASK;

  1571.                 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {

  1572.                     av_log(s->avctx, AV_LOG_ERROR,

  1573.                            "Invalid channel mode %d\n", am);

  1574.                     return AVERROR_INVALIDDATA;

  1575.                 }

  1576.                 if (num_core_channels + !!s->lfe >

  1577.                     FF_ARRAY_ELEMS(dca_default_coeffs[0])) {

  1578.                     avpriv_request_sample(s->avctx, "Downmixing %d channels",

  1579.                                           s->prim_channels + !!s->lfe);

  1580.                     return AVERROR_PATCHWELCOME;

  1581.                 }

  1582.                 for (i = 0; i < num_core_channels + !!s->lfe; i++) {

  1583.                     s->downmix_coef[i][0] = dca_default_coeffs[am][i][0];

  1584.                     s->downmix_coef[i][1] = dca_default_coeffs[am][i][1];

  1585.                 }

  1586.             }

  1587.             av_dlog(s->avctx, "Stereo downmix coeffs:\n");

  1588.             for (i = 0; i < num_core_channels + !!s->lfe; i++) {

  1589.                 av_dlog(s->avctx, "L, input channel %d = %f\n", i,

  1590.                         s->downmix_coef[i][0]);

  1591.                 av_dlog(s->avctx, "R, input channel %d = %f\n", i,

  1592.                         s->downmix_coef[i][1]);

  1593.             }

  1594.             av_dlog(s->avctx, "\n");

  1595.     }

  1596. 

  1597.     if (s->ext_coding)

  1598.         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];

  1599.     else

  1600.         s->core_ext_mask = 0;

  1601. 

  1602.     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;

  1603. 

  1604.     /* only scan for extensions if ext_descr was unknown or indicated a

  1605.      * supported XCh extension */

  1606.     if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {

  1607.         /* if ext_descr was unknown, clear s->core_ext_mask so that the

  1608.          * extensions scan can fill it up */

  1609.         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);

  1610. 

  1611.         /* extensions start at 32-bit boundaries into bitstream */

  1612.         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);

  1613. 

  1614.         while (core_ss_end - get_bits_count(&s->gb) >= 32) {

  1615.             uint32_t bits = get_bits_long(&s->gb, 32);

  1616. 

  1617.             switch (bits) {

  1618.             case 0x5a5a5a5a: {

  1619.                 int ext_amode, xch_fsize;

  1620. 

  1621.                 s->xch_base_channel = s->prim_channels;

  1622. 

  1623.                 /* validate sync word using XCHFSIZE field */

  1624.                 xch_fsize = show_bits(&s->gb, 10);

  1625.                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&

  1626.                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))

  1627.                     continue;

  1628. 

  1629.                 /* skip length-to-end-of-frame field for the moment */

  1630.                 skip_bits(&s->gb, 10);

  1631. 

  1632.                 s->core_ext_mask |= DCA_EXT_XCH;

  1633. 

  1634.                 /* extension amode(number of channels in extension) should be 1 */

  1635.                 /* AFAIK XCh is not used for more channels */

  1636.                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {

  1637.                     av_log(avctx, AV_LOG_ERROR,

  1638.                            "XCh extension amode %d not supported!\n",

  1639.                            ext_amode);

  1640.                     continue;

  1641.                 }

  1642. 

  1643.                 if (s->xch_base_channel < 2) {

  1644.                     avpriv_request_sample(avctx, "XCh with fewer than 2 base channels");

  1645.                     continue;

  1646.                 }

  1647. 

  1648.                 /* much like core primary audio coding header */

  1649.                 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);

  1650. 

  1651.                 for (i = 0; i < (s->sample_blocks / 8); i++)

  1652.                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {

  1653.                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");

  1654.                         continue;

  1655.                     }

  1656. 

  1657.                 s->xch_present = 1;

  1658.                 break;

  1659.             }

  1660.             case 0x47004a03:

  1661.                 /* XXCh: extended channels */

  1662.                 /* usually found either in core or HD part in DTS-HD HRA streams,

  1663.                  * but not in DTS-ES which contains XCh extensions instead */

  1664.                 s->core_ext_mask |= DCA_EXT_XXCH;

  1665.                 ff_dca_xxch_decode_frame(s);

  1666.                 break;

  1667. 

  1668.             case 0x1d95f262: {

  1669.                 int fsize96 = show_bits(&s->gb, 12) + 1;

  1670.                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)

  1671.                     continue;

  1672. 

  1673.                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",

  1674.                        get_bits_count(&s->gb));

  1675.                 skip_bits(&s->gb, 12);

  1676.                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);

  1677.                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));

  1678. 

  1679.                 s->core_ext_mask |= DCA_EXT_X96;

  1680.                 break;

  1681.             }

  1682.             }

  1683. 

  1684.             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);

  1685.         }

  1686.     } else {

  1687.         /* no supported extensions, skip the rest of the core substream */

  1688.         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));

  1689.     }

  1690. 

  1691.     if (s->core_ext_mask & DCA_EXT_X96)

  1692.         s->profile = FF_PROFILE_DTS_96_24;

  1693.     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))

  1694.         s->profile = FF_PROFILE_DTS_ES;

  1695. 

  1696.     /* check for ExSS (HD part) */

  1697.     if (s->dca_buffer_size - s->frame_size > 32 &&

  1698.         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)

  1699.         ff_dca_exss_parse_header(s);

  1700. 

  1701.     avctx->profile = s->profile;

  1702. 

  1703.     full_channels = channels = s->prim_channels + !!s->lfe;

  1704. 

  1705.     /* If we have XXCH then the channel layout is managed differently */

  1706.     /* note that XLL will also have another way to do things */

  1707.     if (!(s->core_ext_mask & DCA_EXT_XXCH)

  1708.         || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0

  1709.             && avctx->request_channels

  1710.             < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))

  1711.     { /* xxx should also do MA extensions */

  1712.         if (s->amode < 16) {

  1713.             avctx->channel_layout = dca_core_channel_layout[s->amode];

  1714. 

  1715.             if (s->prim_channels + !!s->lfe > 2 &&

  1716.                 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {

  1717.                 /*

  1718.                  * Neither the core's auxiliary data nor our default tables contain

  1719.                  * downmix coefficients for the additional channel coded in the XCh

  1720.                  * extension, so when we're doing a Stereo downmix, don't decode it.

  1721.                  */

  1722.                 s->xch_disable = 1;

  1723.             }

  1724. 

  1725. #if FF_API_REQUEST_CHANNELS

  1726. FF_DISABLE_DEPRECATION_WARNINGS

  1727.             if (s->xch_present && !s->xch_disable &&

  1728.                 (!avctx->request_channels ||

  1729.                  avctx->request_channels > num_core_channels + !!s->lfe)) {

  1730. FF_ENABLE_DEPRECATION_WARNINGS

  1731. #else

  1732.             if (s->xch_present && !s->xch_disable) {

  1733. #endif

  1734.                 if (avctx->channel_layout & AV_CH_BACK_CENTER) {

  1735.                     avpriv_request_sample(avctx, "XCh with Back center channel");

  1736.                     return AVERROR_INVALIDDATA;

  1737.                 }

  1738.                 avctx->channel_layout |= AV_CH_BACK_CENTER;

  1739.                 if (s->lfe) {

  1740.                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;

  1741.                     s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];

  1742.                 } else {

  1743.                     s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];

  1744.                 }

  1745.                 if (s->channel_order_tab[s->xch_base_channel] < 0)

  1746.                     return AVERROR_INVALIDDATA;

  1747.             } else {

  1748.                 channels       = num_core_channels + !!s->lfe;

  1749.                 s->xch_present = 0; /* disable further xch processing */

  1750.                 if (s->lfe) {

  1751.                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;

  1752.                     s->channel_order_tab = dca_channel_reorder_lfe[s->amode];

  1753.                 } else

  1754.                     s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];

  1755.             }

  1756. 

  1757.             if (channels > !!s->lfe &&

  1758.                 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)

  1759.                 return AVERROR_INVALIDDATA;

  1760. 

  1761.             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {

  1762.                 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));

  1763.                 return AVERROR_INVALIDDATA;

  1764.             }

  1765. 

  1766.             if (num_core_channels + !!s->lfe > 2 &&

  1767.                 avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {

  1768.                 channels              = 2;

  1769.                 s->output             = s->prim_channels == 2 ? s->amode : DCA_STEREO;

  1770.                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;

  1771.             }

  1772.             else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {

  1773.                 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };

  1774.                 s->channel_order_tab = dca_channel_order_native;

  1775.             }

  1776.             s->lfe_index = dca_lfe_index[s->amode];

  1777.         } else {

  1778.             av_log(avctx, AV_LOG_ERROR,

  1779.                    "Non standard configuration %d !\n", s->amode);

  1780.             return AVERROR_INVALIDDATA;

  1781.         }

  1782. 

  1783.         s->xxch_dmix_embedded = 0;

  1784.     } else {

  1785.         /* we only get here if an XXCH channel set can be added to the mix */

  1786.         channel_mask = s->xxch_core_spkmask;

  1787. 

  1788.         if (avctx->request_channels > 0

  1789.             && avctx->request_channels < s->prim_channels) {

  1790.             channels = num_core_channels + !!s->lfe;

  1791.             for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]

  1792.                                               <= avctx->request_channels; i++) {

  1793.                 channels += s->xxch_chset_nch[i];

  1794.                 channel_mask |= s->xxch_spk_masks[i];

  1795.             }

  1796.         } else {

  1797.             channels = s->prim_channels + !!s->lfe;

  1798.             for (i = 0; i < s->xxch_chset; i++) {

  1799.                 channel_mask |= s->xxch_spk_masks[i];

  1800.             }

  1801.         }

  1802. 

  1803.         /* Given the DTS spec'ed channel mask, generate an avcodec version */

  1804.         channel_layout = 0;

  1805.         for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {

  1806.             if (channel_mask & (1 << i)) {

  1807.                 channel_layout |= map_xxch_to_native[i];

  1808.             }

  1809.         }

  1810. 

  1811.         /* make sure that we have managed to get equivalent dts/avcodec channel

  1812.          * masks in some sense -- unfortunately some channels could overlap */

  1813.         if (av_popcount(channel_mask) != av_popcount(channel_layout)) {

  1814.             av_log(avctx, AV_LOG_DEBUG,

  1815.                    "DTS-XXCH: Inconsistent avcodec/dts channel layouts\n");

  1816.             return AVERROR_INVALIDDATA;

  1817.         }

  1818. 

  1819.         avctx->channel_layout = channel_layout;

  1820. 

  1821.         if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {

  1822.             /* Estimate DTS --> avcodec ordering table */

  1823.             for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {

  1824.                 mask = chset >= 0 ? s->xxch_spk_masks[chset]

  1825.                                   : s->xxch_core_spkmask;

  1826.                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {

  1827.                     if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {

  1828.                         lavc = map_xxch_to_native[i];

  1829.                         posn = av_popcount(channel_layout & (lavc - 1));

  1830.                         s->xxch_order_tab[j++] = posn;

  1831.                     }

  1832.                 }

  1833. 

  1834.             }

  1835. 

  1836.             s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));

  1837.         } else { /* native ordering */

  1838.             for (i = 0; i < channels; i++)

  1839.                 s->xxch_order_tab[i] = i;

  1840. 

  1841.             s->lfe_index = channels - 1;

  1842.         }

  1843. 

  1844.         s->channel_order_tab = s->xxch_order_tab;

  1845.     }

  1846. 

  1847.     if (avctx->channels != channels) {

  1848.         if (avctx->channels)

  1849.             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);

  1850.         avctx->channels = channels;

  1851.     }

  1852. 

  1853.     /* get output buffer */

  1854.     frame->nb_samples = 256 * (s->sample_blocks / 8);

  1855.     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

  1856.         return ret;

  1857.     samples_flt = (float **) frame->extended_data;

  1858. 

  1859.     /* allocate buffer for extra channels if downmixing */

  1860.     if (avctx->channels < full_channels) {

  1861.         ret = av_samples_get_buffer_size(NULL, full_channels - channels,

  1862.                                          frame->nb_samples,

  1863.                                          avctx->sample_fmt, 0);

  1864.         if (ret < 0)

  1865.             return ret;

  1866. 

  1867.         av_fast_malloc(&s->extra_channels_buffer,

  1868.                        &s->extra_channels_buffer_size, ret);

  1869.         if (!s->extra_channels_buffer)

  1870.             return AVERROR(ENOMEM);

  1871. 

  1872.         ret = av_samples_fill_arrays((uint8_t **) s->extra_channels, NULL,

  1873.                                      s->extra_channels_buffer,

  1874.                                      full_channels - channels,

  1875.                                      frame->nb_samples, avctx->sample_fmt, 0);

  1876.         if (ret < 0)

  1877.             return ret;

  1878.     }

  1879. 

  1880.     /* filter to get final output */

  1881.     for (i = 0; i < (s->sample_blocks / 8); i++) {

  1882.         int ch;

  1883. 

  1884.         for (ch = 0; ch < channels; ch++)

  1885.             s->samples_chanptr[ch] = samples_flt[ch] + i * 256;

  1886.         for (; ch < full_channels; ch++)

  1887.             s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;

  1888. 

  1889.         dca_filter_channels(s, i);

  1890. 

  1891.         /* If this was marked as a DTS-ES stream we need to subtract back- */

  1892.         /* channel from SL & SR to remove matrixed back-channel signal */

  1893.         if ((s->source_pcm_res & 1) && s->xch_present) {

  1894.             float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];

  1895.             float *lt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];

  1896.             float *rt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];

  1897.             s->fdsp->vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);

  1898.             s->fdsp->vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);

  1899.         }

  1900. 

  1901.         /* If stream contains XXCH, we might need to undo an embedded downmix */

  1902.         if (s->xxch_dmix_embedded) {

  1903.             /* Loop over channel sets in turn */

  1904.             ch = num_core_channels;

  1905.             for (chset = 0; chset < s->xxch_chset; chset++) {

  1906.                 endch = ch + s->xxch_chset_nch[chset];

  1907.                 mask = s->xxch_dmix_embedded;

  1908. 

  1909.                 /* undo downmix */

  1910.                 for (j = ch; j < endch; j++) {

  1911.                     if (mask & (1 << j)) { /* this channel has been mixed-out */

  1912.                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];

  1913.                         for (k = 0; k < endch; k++) {

  1914.                             achan = s->channel_order_tab[k];

  1915.                             scale = s->xxch_dmix_coeff[j][k];

  1916.                             if (scale != 0.0) {

  1917.                                 dst_chan = s->samples_chanptr[achan];

  1918.                                 s->fdsp->vector_fmac_scalar(dst_chan, src_chan,

  1919.                                                            -scale, 256);

  1920.                             }

  1921.                         }

  1922.                     }

  1923.                 }

  1924. 

  1925.                 /* if a downmix has been embedded then undo the pre-scaling */

  1926.                 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {

  1927.                     scale = s->xxch_dmix_sf[chset];

  1928. 

  1929.                     for (j = 0; j < ch; j++) {

  1930.                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];

  1931.                         for (k = 0; k < 256; k++)

  1932.                             src_chan[k] *= scale;

  1933.                     }

  1934. 

  1935.                     /* LFE channel is always part of core, scale if it exists */

  1936.                     if (s->lfe) {

  1937.                         src_chan = s->samples_chanptr[s->lfe_index];

  1938.                         for (k = 0; k < 256; k++)

  1939.                             src_chan[k] *= scale;

  1940.                     }

  1941.                 }

  1942. 

  1943.                 ch = endch;

  1944.             }

  1945. 

  1946.         }

  1947.     }

  1948. 

  1949.     /* update lfe history */

  1950.     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);

  1951.     for (i = 0; i < 2 * s->lfe * 4; i++)

  1952.         s->lfe_data[i] = s->lfe_data[i + lfe_samples];

  1953. 

  1954.     /* AVMatrixEncoding

  1955.      *

  1956.      * DCA_STEREO_TOTAL (Lt/Rt) is equivalent to Dolby Surround */

  1957.     ret = ff_side_data_update_matrix_encoding(frame,

  1958.                                               (s->output & ~DCA_LFE) == DCA_STEREO_TOTAL ?

  1959.                                               AV_MATRIX_ENCODING_DOLBY : AV_MATRIX_ENCODING_NONE);

  1960.     if (ret < 0)

  1961.         return ret;

  1962. 

  1963.     *got_frame_ptr = 1;

  1964. 

  1965.     return buf_size;

  1966. }

  1967. 

  1968. /**

  1969.  * DCA initialization

  1970.  *

  1971.  * @param avctx     pointer to the AVCodecContext

  1972.  */

  1973. 

  1974. static av_cold int dca_decode_init(AVCodecContext *avctx)

  1975. {

  1976.     DCAContext *s = avctx->priv_data;

  1977. 

  1978.     s->avctx = avctx;

  1979.     dca_init_vlcs();

  1980. 

  1981.     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);

  1982.     if (!s->fdsp)

  1983.         return AVERROR(ENOMEM);

  1984. 

  1985.     ff_mdct_init(&s->imdct, 6, 1, 1.0);

  1986.     ff_synth_filter_init(&s->synth);

  1987.     ff_dcadsp_init(&s->dcadsp);

  1988.     ff_fmt_convert_init(&s->fmt_conv, avctx);

  1989. 

  1990.     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

  1991. 

  1992.     /* allow downmixing to stereo */

  1993. #if FF_API_REQUEST_CHANNELS

  1994. FF_DISABLE_DEPRECATION_WARNINGS

  1995.     if (avctx->request_channels == 2)

  1996.         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;

  1997. FF_ENABLE_DEPRECATION_WARNINGS

  1998. #endif

  1999.     if (avctx->channels > 2 &&

  2000.         avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)

  2001.         avctx->channels = 2;

  2002. 

  2003.     return 0;

  2004. }

  2005. 

  2006. static av_cold int dca_decode_end(AVCodecContext *avctx)

  2007. {

  2008.     DCAContext *s = avctx->priv_data;

  2009.     ff_mdct_end(&s->imdct);

  2010.     av_freep(&s->extra_channels_buffer);

  2011.     av_freep(&s->fdsp);

  2012.     return 0;

  2013. }

  2014. 

  2015. static const AVProfile profiles[] = {

  2016.     { FF_PROFILE_DTS,        "DTS"        },

  2017.     { FF_PROFILE_DTS_ES,     "DTS-ES"     },

  2018.     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },

  2019.     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },

  2020.     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },

  2021.     { FF_PROFILE_UNKNOWN },

  2022. };

  2023. 

  2024. static const AVOption options[] = {

  2025.     { "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 },

  2026.     { NULL },

  2027. };

  2028. 

  2029. static const AVClass dca_decoder_class = {

  2030.     .class_name = "DCA decoder",

  2031.     .item_name  = av_default_item_name,

  2032.     .option     = options,

  2033.     .version    = LIBAVUTIL_VERSION_INT,

  2034.     .category   = AV_CLASS_CATEGORY_DECODER,

  2035. };

  2036. 

  2037. AVCodec ff_dca_decoder = {

  2038.     .name            = "dca",

  2039.     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

  2040.     .type            = AVMEDIA_TYPE_AUDIO,

  2041.     .id              = AV_CODEC_ID_DTS,

  2042.     .priv_data_size  = sizeof(DCAContext),

  2043.     .init            = dca_decode_init,

  2044.     .decode          = dca_decode_frame,

  2045.     .close           = dca_decode_end,

  2046.     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,

  2047.     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

  2048.                                                        AV_SAMPLE_FMT_NONE },

  2049.     .profiles        = NULL_IF_CONFIG_SMALL(profiles),

  2050.     .priv_class      = &dca_decoder_class,

  2051. };