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.
35406 Commits
32 Branches
649MB
Tree: c3e15f7b39
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c3e15f7b39'
${ noResults }
FFmpeg/libavcodec/dcadec.c

1979 lines
73KB
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 Libav.

  9.  *

  10.  * Libav is free software; you can redistribute it and/or

  11.  * modify it under the terms of the GNU Lesser General Public

  12.  * License as published by the Free Software Foundation; either

  13.  * version 2.1 of the License, or (at your option) any later version.

  14.  *

  15.  * Libav is distributed in the hope that it will be useful,

  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  18.  * Lesser General Public License for more details.

  19.  *

  20.  * You should have received a copy of the GNU Lesser General Public

  21.  * License along with Libav; if not, write to the Free Software

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

  23.  */

  24. 

  25. #include <math.h>

  26. #include <stddef.h>

  27. #include <stdio.h>

  28. 

  29. #include "libavutil/common.h"

  30. #include "libavutil/float_dsp.h"

  31. #include "libavutil/intmath.h"

  32. #include "libavutil/intreadwrite.h"

  33. #include "libavutil/mathematics.h"

  34. #include "libavutil/audioconvert.h"

  35. #include "libavutil/samplefmt.h"

  36. #include "avcodec.h"

  37. #include "dsputil.h"

  38. #include "fft.h"

  39. #include "get_bits.h"

  40. #include "put_bits.h"

  41. #include "dcadata.h"

  42. #include "dcahuff.h"

  43. #include "dca.h"

  44. #include "dca_parser.h"

  45. #include "synth_filter.h"

  46. #include "dcadsp.h"

  47. #include "fmtconvert.h"

  48. 

  49. #if ARCH_ARM

  50. #   include "arm/dca.h"

  51. #endif

  52. 

  53. //#define TRACE

  54. 

  55. #define DCA_PRIM_CHANNELS_MAX  (7)

  56. #define DCA_SUBBANDS          (32)

  57. #define DCA_ABITS_MAX         (32)      /* Should be 28 */

  58. #define DCA_SUBSUBFRAMES_MAX   (4)

  59. #define DCA_SUBFRAMES_MAX     (16)

  60. #define DCA_BLOCKS_MAX        (16)

  61. #define DCA_LFE_MAX            (3)

  62. 

  63. enum DCAMode {

  64.     DCA_MONO = 0,

  65.     DCA_CHANNEL,

  66.     DCA_STEREO,

  67.     DCA_STEREO_SUMDIFF,

  68.     DCA_STEREO_TOTAL,

  69.     DCA_3F,

  70.     DCA_2F1R,

  71.     DCA_3F1R,

  72.     DCA_2F2R,

  73.     DCA_3F2R,

  74.     DCA_4F2R

  75. };

  76. 

  77. /* these are unconfirmed but should be mostly correct */

  78. enum DCAExSSSpeakerMask {

  79.     DCA_EXSS_FRONT_CENTER          = 0x0001,

  80.     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,

  81.     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,

  82.     DCA_EXSS_LFE                   = 0x0008,

  83.     DCA_EXSS_REAR_CENTER           = 0x0010,

  84.     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,

  85.     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,

  86.     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,

  87.     DCA_EXSS_OVERHEAD              = 0x0100,

  88.     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,

  89.     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,

  90.     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,

  91.     DCA_EXSS_LFE2                  = 0x1000,

  92.     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,

  93.     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,

  94.     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,

  95. };

  96. 

  97. enum DCAExtensionMask {

  98.     DCA_EXT_CORE       = 0x001, ///< core in core substream

  99.     DCA_EXT_XXCH       = 0x002, ///< XXCh channels extension in core substream

  100.     DCA_EXT_X96        = 0x004, ///< 96/24 extension in core substream

  101.     DCA_EXT_XCH        = 0x008, ///< XCh channel extension in core substream

  102.     DCA_EXT_EXSS_CORE  = 0x010, ///< core in ExSS (extension substream)

  103.     DCA_EXT_EXSS_XBR   = 0x020, ///< extended bitrate extension in ExSS

  104.     DCA_EXT_EXSS_XXCH  = 0x040, ///< XXCh channels extension in ExSS

  105.     DCA_EXT_EXSS_X96   = 0x080, ///< 96/24 extension in ExSS

  106.     DCA_EXT_EXSS_LBR   = 0x100, ///< low bitrate component in ExSS

  107.     DCA_EXT_EXSS_XLL   = 0x200, ///< lossless extension in ExSS

  108. };

  109. 

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

  111. static const int dca_ext_audio_descr_mask[] = {

  112.     DCA_EXT_XCH,

  113.     -1,

  114.     DCA_EXT_X96,

  115.     DCA_EXT_XCH | DCA_EXT_X96,

  116.     -1,

  117.     -1,

  118.     DCA_EXT_XXCH,

  119.     -1,

  120. };

  121. 

  122. /* extensions that reside in core substream */

  123. #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)

  124. 

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

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

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

  128.  *

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

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

  131.  * OV -> center back

  132.  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO

  133.  */

  134. static const uint64_t dca_core_channel_layout[] = {

  135.     AV_CH_FRONT_CENTER,                                                     ///< 1, A

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

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

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

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

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

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

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

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

  144. 

  145.     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |

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

  147. 

  148.     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |

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

  150. 

  151.     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |

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

  153. 

  154.     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |

  155.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |

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

  157. 

  158.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |

  159.     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |

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

  161. 

  162.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |

  163.     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |

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

  165. 

  166.     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |

  167.     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |

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

  169. };

  170. 

  171. static const int8_t dca_lfe_index[] = {

  172.     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3

  173. };

  174. 

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

  176.     { 0, -1, -1, -1, -1, -1, -1, -1, -1},

  177.     { 0,  1, -1, -1, -1, -1, -1, -1, -1},

  178.     { 0,  1, -1, -1, -1, -1, -1, -1, -1},

  179.     { 0,  1, -1, -1, -1, -1, -1, -1, -1},

  180.     { 0,  1, -1, -1, -1, -1, -1, -1, -1},

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

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

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

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

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

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

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

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

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

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

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

  192. };

  193. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  211. };

  212. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  230. };

  231. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  249. };

  250. 

  251. #define DCA_DOLBY                  101           /* FIXME */

  252. 

  253. #define DCA_CHANNEL_BITS             6

  254. #define DCA_CHANNEL_MASK          0x3F

  255. 

  256. #define DCA_LFE                   0x80

  257. 

  258. #define HEADER_SIZE                 14

  259. 

  260. #define DCA_MAX_FRAME_SIZE       16384

  261. #define DCA_MAX_EXSS_HEADER_SIZE  4096

  262. 

  263. #define DCA_BUFFER_PADDING_SIZE   1024

  264. 

  265. /** Bit allocation */

  266. typedef struct {

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

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

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

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

  271. } BitAlloc;

  272. 

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

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

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

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

  277. 

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

  279.                                          int idx)

  280. {

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

  282.            ba->offset;

  283. }

  284. 

  285. typedef struct {

  286.     AVCodecContext *avctx;

  287.     AVFrame frame;

  288.     /* Frame header */

  289.     int frame_type;             ///< type of the current frame

  290.     int samples_deficit;        ///< deficit sample count

  291.     int crc_present;            ///< crc is present in the bitstream

  292.     int sample_blocks;          ///< number of PCM sample blocks

  293.     int frame_size;             ///< primary frame byte size

  294.     int amode;                  ///< audio channels arrangement

  295.     int sample_rate;            ///< audio sampling rate

  296.     int bit_rate;               ///< transmission bit rate

  297.     int bit_rate_index;         ///< transmission bit rate index

  298. 

  299.     int downmix;                ///< embedded downmix enabled

  300.     int dynrange;               ///< embedded dynamic range flag

  301.     int timestamp;              ///< embedded time stamp flag

  302.     int aux_data;               ///< auxiliary data flag

  303.     int hdcd;                   ///< source material is mastered in HDCD

  304.     int ext_descr;              ///< extension audio descriptor flag

  305.     int ext_coding;             ///< extended coding flag

  306.     int aspf;                   ///< audio sync word insertion flag

  307.     int lfe;                    ///< low frequency effects flag

  308.     int predictor_history;      ///< predictor history flag

  309.     int header_crc;             ///< header crc check bytes

  310.     int multirate_inter;        ///< multirate interpolator switch

  311.     int version;                ///< encoder software revision

  312.     int copy_history;           ///< copy history

  313.     int source_pcm_res;         ///< source pcm resolution

  314.     int front_sum;              ///< front sum/difference flag

  315.     int surround_sum;           ///< surround sum/difference flag

  316.     int dialog_norm;            ///< dialog normalisation parameter

  317. 

  318.     /* Primary audio coding header */

  319.     int subframes;              ///< number of subframes

  320.     int is_channels_set;        ///< check for if the channel number is already set

  321.     int total_channels;         ///< number of channels including extensions

  322.     int prim_channels;          ///< number of primary audio channels

  323.     int subband_activity[DCA_PRIM_CHANNELS_MAX];    ///< subband activity count

  324.     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    ///< high frequency vq start subband

  325.     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     ///< joint intensity coding index

  326.     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   ///< transient mode code book

  327.     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; ///< scale factor code book

  328.     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    ///< bit allocation quantizer select

  329.     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; ///< quantization index codebook select

  330.     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   ///< scale factor adjustment

  331. 

  332.     /* Primary audio coding side information */

  333.     int subsubframes[DCA_SUBFRAMES_MAX];                         ///< number of subsubframes

  334.     int partial_samples[DCA_SUBFRAMES_MAX];                      ///< partial subsubframe samples count

  335.     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< prediction mode (ADPCM used or not)

  336.     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      ///< prediction VQ coefs

  337.     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           ///< bit allocation index

  338.     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    ///< transition mode (transients)

  339.     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    ///< scale factors (2 if transient)

  340.     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       ///< joint subband scale factors codebook

  341.     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; ///< joint subband scale factors

  342.     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  ///< stereo downmix coefficients

  343.     int dynrange_coef;                                           ///< dynamic range coefficient

  344. 

  345.     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       ///< VQ encoded high frequency subbands

  346. 

  347.     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      ///< Low frequency effect data

  348.     int lfe_scale_factor;

  349. 

  350.     /* Subband samples history (for ADPCM) */

  351.     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];

  352.     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];

  353.     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];

  354.     int hist_index[DCA_PRIM_CHANNELS_MAX];

  355.     DECLARE_ALIGNED(32, float, raXin)[32];

  356. 

  357.     int output;                 ///< type of output

  358. 

  359.     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];

  360.     float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];

  361.     float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];

  362.     uint8_t *extra_channels_buffer;

  363.     unsigned int extra_channels_buffer_size;

  364. 

  365.     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];

  366.     int dca_buffer_size;        ///< how much data is in the dca_buffer

  367. 

  368.     const int8_t *channel_order_tab;  ///< channel reordering table, lfe and non lfe

  369.     GetBitContext gb;

  370.     /* Current position in DCA frame */

  371.     int current_subframe;

  372.     int current_subsubframe;

  373. 

  374.     int core_ext_mask;          ///< present extensions in the core substream

  375. 

  376.     /* XCh extension information */

  377.     int xch_present;            ///< XCh extension present and valid

  378.     int xch_base_channel;       ///< index of first (only) channel containing XCH data

  379. 

  380.     /* ExSS header parser */

  381.     int static_fields;          ///< static fields present

  382.     int mix_metadata;           ///< mixing metadata present

  383.     int num_mix_configs;        ///< number of mix out configurations

  384.     int mix_config_num_ch[4];   ///< number of channels in each mix out configuration

  385. 

  386.     int profile;

  387. 

  388.     int debug_flag;             ///< used for suppressing repeated error messages output

  389.     AVFloatDSPContext fdsp;

  390.     FFTContext imdct;

  391.     SynthFilterContext synth;

  392.     DCADSPContext dcadsp;

  393.     FmtConvertContext fmt_conv;

  394. } DCAContext;

  395. 

  396. static const uint16_t dca_vlc_offs[] = {

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

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

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

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

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

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

  403. };

  404. 

  405. static av_cold void dca_init_vlcs(void)

  406. {

  407.     static int vlcs_initialized = 0;

  408.     int i, j, c = 14;

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

  410. 

  411.     if (vlcs_initialized)

  412.         return;

  413. 

  414.     dca_bitalloc_index.offset = 1;

  415.     dca_bitalloc_index.wrap = 2;

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

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

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

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

  420.                  bitalloc_12_bits[i], 1, 1,

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

  422.     }

  423.     dca_scalefactor.offset = -64;

  424.     dca_scalefactor.wrap = 2;

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

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

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

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

  429.                  scales_bits[i], 1, 1,

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

  431.     }

  432.     dca_tmode.offset = 0;

  433.     dca_tmode.wrap = 1;

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

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

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

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

  438.                  tmode_bits[i], 1, 1,

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

  440.     }

  441. 

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

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

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

  445.                 break;

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

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

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

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

  450. 

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

  452.                      bitalloc_sizes[i],

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

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

  455.             c++;

  456.         }

  457.     vlcs_initialized = 1;

  458. }

  459. 

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

  461. {

  462.     while (len--)

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

  464. }

  465. 

  466. static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)

  467. {

  468.     int i, j;

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

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

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

  472. 

  473.     s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;

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

  475. 

  476.     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)

  477.         s->prim_channels = DCA_PRIM_CHANNELS_MAX;

  478. 

  479. 

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

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

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

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

  484.     }

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

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

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

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

  489.     }

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

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

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

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

  494. 

  495.     /* Get codebooks quantization indexes */

  496.     if (!base_channel)

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

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

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

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

  501. 

  502.     /* Get scale factor adjustment */

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

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

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

  506. 

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

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

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

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

  511. 

  512.     if (s->crc_present) {

  513.         /* Audio header CRC check */

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

  515.     }

  516. 

  517.     s->current_subframe    = 0;

  518.     s->current_subsubframe = 0;

  519. 

  520. #ifdef TRACE

  521.     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);

  522.     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);

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

  524.         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",

  525.                s->subband_activity[i]);

  526.         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",

  527.                s->vq_start_subband[i]);

  528.         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",

  529.                s->joint_intensity[i]);

  530.         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",

  531.                s->transient_huffman[i]);

  532.         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",

  533.                s->scalefactor_huffman[i]);

  534.         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",

  535.                s->bitalloc_huffman[i]);

  536.         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");

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

  538.             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);

  539.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  540.         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");

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

  542.             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);

  543.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  544.     }

  545. #endif

  546. 

  547.     return 0;

  548. }

  549. 

  550. static int dca_parse_frame_header(DCAContext *s)

  551. {

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

  553. 

  554.     /* Sync code */

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

  556. 

  557.     /* Frame header */

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

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

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

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

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

  563.     if (s->frame_size < 95)

  564.         return AVERROR_INVALIDDATA;

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

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

  567.     if (!s->sample_rate)

  568.         return AVERROR_INVALIDDATA;

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

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

  571.     if (!s->bit_rate)

  572.         return AVERROR_INVALIDDATA;

  573. 

  574.     s->downmix           = get_bits(&s->gb, 1);

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

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

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

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

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

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

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

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

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

  584. 

  585.     /* TODO: check CRC */

  586.     if (s->crc_present)

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

  588. 

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

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

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

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

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

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

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

  596. 

  597.     /* FIXME: channels mixing levels */

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

  599.     if (s->lfe)

  600.         s->output |= DCA_LFE;

  601. 

  602. #ifdef TRACE

  603.     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);

  604.     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);

  605.     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);

  606.     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",

  607.            s->sample_blocks, s->sample_blocks * 32);

  608.     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);

  609.     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",

  610.            s->amode, dca_channels[s->amode]);

  611.     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",

  612.            s->sample_rate);

  613.     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",

  614.            s->bit_rate);

  615.     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);

  616.     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);

  617.     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);

  618.     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);

  619.     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);

  620.     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);

  621.     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);

  622.     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);

  623.     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);

  624.     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",

  625.            s->predictor_history);

  626.     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);

  627.     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",

  628.            s->multirate_inter);

  629.     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);

  630.     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);

  631.     av_log(s->avctx, AV_LOG_DEBUG,

  632.            "source pcm resolution: %i (%i bits/sample)\n",

  633.            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);

  634.     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);

  635.     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);

  636.     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);

  637.     av_log(s->avctx, AV_LOG_DEBUG, "\n");

  638. #endif

  639. 

  640.     /* Primary audio coding header */

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

  642. 

  643.     return dca_parse_audio_coding_header(s, 0);

  644. }

  645. 

  646. 

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

  648. {

  649.     if (level < 5) {

  650.         /* huffman encoded */

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

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

  653.     } else if (level < 8) {

  654.         if (level + 1 > log2range) {

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

  656.             value = get_bits(gb, log2range);

  657.         } else {

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

  659.         }

  660.     }

  661.     return value;

  662. }

  663. 

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

  665. {

  666.     /* Primary audio coding side information */

  667.     int j, k;

  668. 

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

  670.         return AVERROR_INVALIDDATA;

  671. 

  672.     if (!base_channel) {

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

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

  675.     }

  676. 

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

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

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

  680.     }

  681. 

  682.     /* Get prediction codebook */

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

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

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

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

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

  688.             }

  689.         }

  690.     }

  691. 

  692.     /* Bit allocation index */

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

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

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

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

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

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

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

  700.                 av_log(s->avctx, AV_LOG_ERROR,

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

  702.                 return AVERROR_INVALIDDATA;

  703.             } else {

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

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

  706.             }

  707. 

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

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

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

  711.                 return AVERROR_INVALIDDATA;

  712.             }

  713.         }

  714.     }

  715. 

  716.     /* Transition mode */

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

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

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

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

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

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

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

  724.             }

  725.         }

  726.     }

  727. 

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

  729.         return AVERROR_INVALIDDATA;

  730. 

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

  732.         const uint32_t *scale_table;

  733.         int scale_sum, log_size;

  734. 

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

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

  737. 

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

  739.             scale_table = scale_factor_quant7;

  740.             log_size = 7;

  741.         } else {

  742.             scale_table = scale_factor_quant6;

  743.             log_size = 6;

  744.         }

  745. 

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

  747.         scale_sum = 0;

  748. 

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

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

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

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

  753.             }

  754. 

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

  756.                 /* Get second scale factor */

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

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

  759.             }

  760.         }

  761.     }

  762. 

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

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

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

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

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

  768.     }

  769. 

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

  771.         return AVERROR_INVALIDDATA;

  772. 

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

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

  775.         int source_channel;

  776. 

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

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

  779.             int scale = 0;

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

  781. 

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

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

  784. 

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

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

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

  788.             }

  789. 

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

  791.                 av_log(s->avctx, AV_LOG_DEBUG,

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

  793.                 s->debug_flag |= 0x02;

  794.             }

  795.         }

  796.     }

  797. 

  798.     /* Stereo downmix coefficients */

  799.     if (!base_channel && s->prim_channels > 2) {

  800.         if (s->downmix) {

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

  802.                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);

  803.                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);

  804.             }

  805.         } else {

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

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

  808.                 av_log(s->avctx, AV_LOG_ERROR,

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

  810.                 return AVERROR_INVALIDDATA;

  811.             }

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

  813.                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];

  814.                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];

  815.             }

  816.         }

  817.     }

  818. 

  819.     /* Dynamic range coefficient */

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

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

  822. 

  823.     /* Side information CRC check word */

  824.     if (s->crc_present) {

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

  826.     }

  827. 

  828.     /*

  829.      * Primary audio data arrays

  830.      */

  831. 

  832.     /* VQ encoded high frequency subbands */

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

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

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

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

  837. 

  838.     /* Low frequency effect data */

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

  840.         /* LFE samples */

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

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

  843.         float lfe_scale;

  844. 

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

  846.             /* Signed 8 bits int */

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

  848.         }

  849. 

  850.         /* Scale factor index */

  851.         skip_bits(&s->gb, 1);

  852.         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];

  853. 

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

  855.         lfe_scale = 0.035 * s->lfe_scale_factor;

  856. 

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

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

  859.     }

  860. 

  861. #ifdef TRACE

  862.     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",

  863.            s->subsubframes[s->current_subframe]);

  864.     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",

  865.            s->partial_samples[s->current_subframe]);

  866. 

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

  868.         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");

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

  870.             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);

  871.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  872.     }

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

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

  875.             av_log(s->avctx, AV_LOG_DEBUG,

  876.                    "prediction coefs: %f, %f, %f, %f\n",

  877.                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,

  878.                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,

  879.                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,

  880.                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);

  881.     }

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

  883.         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");

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

  885.             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);

  886.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  887.     }

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

  889.         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");

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

  891.             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);

  892.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  893.     }

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

  895.         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");

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

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

  898.                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);

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

  900.                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);

  901.         }

  902.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  903.     }

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

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

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

  907.             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");

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

  909.                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);

  910.             av_log(s->avctx, AV_LOG_DEBUG, "\n");

  911.         }

  912.     }

  913.     if (!base_channel && s->prim_channels > 2 && s->downmix) {

  914.         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");

  915.         for (j = 0; j < s->prim_channels; j++) {

  916.             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,

  917.                    dca_downmix_coeffs[s->downmix_coef[j][0]]);

  918.             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,

  919.                    dca_downmix_coeffs[s->downmix_coef[j][1]]);

  920.         }

  921.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  922.     }

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

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

  925.             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);

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

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

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

  929. 

  930.         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");

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

  932.             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);

  933.         av_log(s->avctx, AV_LOG_DEBUG, "\n");

  934.     }

  935. #endif

  936. 

  937.     return 0;

  938. }

  939. 

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

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

  942.                             float scale)

  943. {

  944.     const float *prCoeff;

  945.     int i;

  946. 

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

  948.     int subindex;

  949. 

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

  951. 

  952.     /* Select filter */

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

  954.         prCoeff = fir_32bands_nonperfect;

  955.     else                        /* Perfect reconstruction */

  956.         prCoeff = fir_32bands_perfect;

  957. 

  958.     for (i = sb_act; i < 32; i++)

  959.         s->raXin[i] = 0.0;

  960. 

  961.     /* Reconstructed channel sample index */

  962.     for (subindex = 0; subindex < 8; subindex++) {

  963.         /* Load in one sample from each subband and clear inactive subbands */

  964.         for (i = 0; i < sb_act; i++) {

  965.             unsigned sign = (i - 1) & 2;

  966.             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;

  967.             AV_WN32A(&s->raXin[i], v);

  968.         }

  969. 

  970.         s->synth.synth_filter_float(&s->imdct,

  971.                                     s->subband_fir_hist[chans],

  972.                                     &s->hist_index[chans],

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

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

  975.         samples_out += 32;

  976.     }

  977. }

  978. 

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

  980.                                   int num_deci_sample, float *samples_in,

  981.                                   float *samples_out, float scale)

  982. {

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

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

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

  986.      *   from last subframe as history.

  987.      *

  988.      * samples_out: An array holding interpolated samples

  989.      */

  990. 

  991.     int decifactor;

  992.     const float *prCoeff;

  993.     int deciindex;

  994. 

  995.     /* Select decimation filter */

  996.     if (decimation_select == 1) {

  997.         decifactor = 64;

  998.         prCoeff = lfe_fir_128;

  999.     } else {

  1000.         decifactor = 32;

  1001.         prCoeff = lfe_fir_64;

  1002.     }

  1003.     /* Interpolation */

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

  1005.         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);

  1006.         samples_in++;

  1007.         samples_out += 2 * decifactor;

  1008.     }

  1009. }

  1010. 

  1011. /* downmixing routines */

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

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

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

  1015. 

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

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

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

  1019. 

  1020. #define MIX_FRONT3(samples, coef)                                      \

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

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

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

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

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

  1026. 

  1027. #define DOWNMIX_TO_STEREO(op1, op2)             \

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

  1029.         op1                                     \

  1030.         op2                                     \

  1031.     }

  1032. 

  1033. static void dca_downmix(float **samples, int srcfmt,

  1034.                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],

  1035.                         const int8_t *channel_mapping)

  1036. {

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

  1038.     int i;

  1039.     float t, u, v;

  1040.     float coef[DCA_PRIM_CHANNELS_MAX][2];

  1041. 

  1042.     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {

  1043.         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];

  1044.         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];

  1045.     }

  1046. 

  1047.     switch (srcfmt) {

  1048.     case DCA_MONO:

  1049.     case DCA_CHANNEL:

  1050.     case DCA_STEREO_TOTAL:

  1051.     case DCA_STEREO_SUMDIFF:

  1052.     case DCA_4F2R:

  1053.         av_log(NULL, 0, "Not implemented!\n");

  1054.         break;

  1055.     case DCA_STEREO:

  1056.         break;

  1057.     case DCA_3F:

  1058.         c = channel_mapping[0];

  1059.         l = channel_mapping[1];

  1060.         r = channel_mapping[2];

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

  1062.         break;

  1063.     case DCA_2F1R:

  1064.         s = channel_mapping[2];

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

  1066.         break;

  1067.     case DCA_3F1R:

  1068.         c = channel_mapping[0];

  1069.         l = channel_mapping[1];

  1070.         r = channel_mapping[2];

  1071.         s = channel_mapping[3];

  1072.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

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

  1074.         break;

  1075.     case DCA_2F2R:

  1076.         sl = channel_mapping[2];

  1077.         sr = channel_mapping[3];

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

  1079.         break;

  1080.     case DCA_3F2R:

  1081.         c  = channel_mapping[0];

  1082.         l  = channel_mapping[1];

  1083.         r  = channel_mapping[2];

  1084.         sl = channel_mapping[3];

  1085.         sr = channel_mapping[4];

  1086.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

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

  1088.         break;

  1089.     }

  1090. }

  1091. 

  1092. 

  1093. #ifndef decode_blockcodes

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

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

  1096. static int decode_blockcode(int code, int levels, int *values)

  1097. {

  1098.     int i;

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

  1100. 

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

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

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

  1104.         code = div;

  1105.     }

  1106. 

  1107.     return code;

  1108. }

  1109. 

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

  1111. {

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

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

  1114. }

  1115. #endif

  1116. 

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

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

  1119. 

  1120. #ifndef int8x8_fmul_int32

  1121. static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)

  1122. {

  1123.     float fscale = scale / 16.0;

  1124.     int i;

  1125.     for (i = 0; i < 8; i++)

  1126.         dst[i] = src[i] * fscale;

  1127. }

  1128. #endif

  1129. 

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

  1131. {

  1132.     int k, l;

  1133.     int subsubframe = s->current_subsubframe;

  1134. 

  1135.     const float *quant_step_table;

  1136. 

  1137.     /* FIXME */

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

  1139.     LOCAL_ALIGNED_16(int, block, [8]);

  1140. 

  1141.     /*

  1142.      * Audio data

  1143.      */

  1144. 

  1145.     /* Select quantization step size table */

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

  1147.         quant_step_table = lossless_quant_d;

  1148.     else

  1149.         quant_step_table = lossy_quant_d;

  1150. 

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

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

  1153.             return AVERROR_INVALIDDATA;

  1154. 

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

  1156.             int m;

  1157. 

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

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

  1160. 

  1161.             float quant_step_size = quant_step_table[abits];

  1162. 

  1163.             /*

  1164.              * Determine quantization index code book and its type

  1165.              */

  1166. 

  1167.             /* Select quantization index code book */

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

  1169. 

  1170.             /*

  1171.              * Extract bits from the bit stream

  1172.              */

  1173.             if (!abits) {

  1174.                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));

  1175.             } else {

  1176.                 /* Deal with transients */

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

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

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

  1180. 

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

  1182.                     if (abits <= 7) {

  1183.                         /* Block code */

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

  1185. 

  1186.                         size   = abits_sizes[abits - 1];

  1187.                         levels = abits_levels[abits - 1];

  1188. 

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

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

  1191.                         err = decode_blockcodes(block_code1, block_code2,

  1192.                                                 levels, block);

  1193.                         if (err) {

  1194.                             av_log(s->avctx, AV_LOG_ERROR,

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

  1196.                             return AVERROR_INVALIDDATA;

  1197.                         }

  1198.                     } else {

  1199.                         /* no coding */

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

  1201.                             block[m] = get_sbits(&s->gb, abits - 3);

  1202.                     }

  1203.                 } else {

  1204.                     /* Huffman coded */

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

  1206.                         block[m] = get_bitalloc(&s->gb,

  1207.                                                 &dca_smpl_bitalloc[abits], sel);

  1208.                 }

  1209. 

  1210.                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],

  1211.                                                        block, rscale, 8);

  1212.             }

  1213. 

  1214.             /*

  1215.              * Inverse ADPCM if in prediction mode

  1216.              */

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

  1218.                 int n;

  1219.                 for (m = 0; m < 8; m++) {

  1220.                     for (n = 1; n <= 4; n++)

  1221.                         if (m >= n)

  1222.                             subband_samples[k][l][m] +=

  1223.                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *

  1224.                                  subband_samples[k][l][m - n] / 8192);

  1225.                         else if (s->predictor_history)

  1226.                             subband_samples[k][l][m] +=

  1227.                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *

  1228.                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);

  1229.                 }

  1230.             }

  1231.         }

  1232. 

  1233.         /*

  1234.          * Decode VQ encoded high frequencies

  1235.          */

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

  1237.             /* 1 vector -> 32 samples but we only need the 8 samples

  1238.              * for this subsubframe. */

  1239.             int hfvq = s->high_freq_vq[k][l];

  1240. 

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

  1242.                 av_log(s->avctx, AV_LOG_DEBUG,

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

  1244.                 s->debug_flag |= 0x01;

  1245.             }

  1246. 

  1247.             int8x8_fmul_int32(subband_samples[k][l],

  1248.                               &high_freq_vq[hfvq][subsubframe * 8],

  1249.                               s->scale_factor[k][l][0]);

  1250.         }

  1251.     }

  1252. 

  1253.     /* Check for DSYNC after subsubframe */

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

  1255.         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */

  1256. #ifdef TRACE

  1257.             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");

  1258. #endif

  1259.         } else {

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

  1261.         }

  1262.     }

  1263. 

  1264.     /* Backup predictor history for adpcm */

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

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

  1267.             memcpy(s->subband_samples_hist[k][l],

  1268.                    &subband_samples[k][l][4],

  1269.                    4 * sizeof(subband_samples[0][0][0]));

  1270. 

  1271.     return 0;

  1272. }

  1273. 

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

  1275. {

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

  1277.     int k;

  1278. 

  1279.     /* 32 subbands QMF */

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

  1281. /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,

  1282.                                             0, 8388608.0, 8388608.0 };*/

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

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

  1285.                         M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);

  1286.     }

  1287. 

  1288.     /* Down mixing */

  1289.     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {

  1290.         dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);

  1291.     }

  1292. 

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

  1294.     if (s->output & DCA_LFE) {

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

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

  1297.                               s->samples_chanptr[dca_lfe_index[s->amode]],

  1298.                               1.0 / (256.0 * 32768.0));

  1299.         /* Outputs 20bits pcm samples */

  1300.     }

  1301. 

  1302.     return 0;

  1303. }

  1304. 

  1305. 

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

  1307. {

  1308.     int aux_data_count = 0, i;

  1309. 

  1310.     /*

  1311.      * Unpack optional information

  1312.      */

  1313. 

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

  1315.     if (!base_channel) {

  1316.         if (s->timestamp)

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

  1318. 

  1319.         if (s->aux_data)

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

  1321. 

  1322.         for (i = 0; i < aux_data_count; i++)

  1323.             get_bits(&s->gb, 8);

  1324. 

  1325.         if (s->crc_present && (s->downmix || s->dynrange))

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

  1327.     }

  1328. 

  1329.     return 0;

  1330. }

  1331. 

  1332. /**

  1333.  * Decode a dca frame block

  1334.  *

  1335.  * @param s     pointer to the DCAContext

  1336.  */

  1337. 

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

  1339. {

  1340.     int ret;

  1341. 

  1342.     /* Sanity check */

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

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

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

  1346.         return AVERROR_INVALIDDATA;

  1347.     }

  1348. 

  1349.     if (!s->current_subsubframe) {

  1350. #ifdef TRACE

  1351.         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");

  1352. #endif

  1353.         /* Read subframe header */

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

  1355.             return ret;

  1356.     }

  1357. 

  1358.     /* Read subsubframe */

  1359. #ifdef TRACE

  1360.     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");

  1361. #endif

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

  1363.         return ret;

  1364. 

  1365.     /* Update state */

  1366.     s->current_subsubframe++;

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

  1368.         s->current_subsubframe = 0;

  1369.         s->current_subframe++;

  1370.     }

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

  1372. #ifdef TRACE

  1373.         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");

  1374. #endif

  1375.         /* Read subframe footer */

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

  1377.             return ret;

  1378.     }

  1379. 

  1380.     return 0;

  1381. }

  1382. 

  1383. /**

  1384.  * Return the number of channels in an ExSS speaker mask (HD)

  1385.  */

  1386. static int dca_exss_mask2count(int mask)

  1387. {

  1388.     /* count bits that mean speaker pairs twice */

  1389.     return av_popcount(mask) +

  1390.            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |

  1391.                                DCA_EXSS_FRONT_LEFT_RIGHT       |

  1392.                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |

  1393.                                DCA_EXSS_WIDE_LEFT_RIGHT        |

  1394.                                DCA_EXSS_SIDE_LEFT_RIGHT        |

  1395.                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |

  1396.                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |

  1397.                                DCA_EXSS_REAR_LEFT_RIGHT        |

  1398.                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));

  1399. }

  1400. 

  1401. /**

  1402.  * Skip mixing coefficients of a single mix out configuration (HD)

  1403.  */

  1404. static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)

  1405. {

  1406.     int i;

  1407. 

  1408.     for (i = 0; i < channels; i++) {

  1409.         int mix_map_mask = get_bits(gb, out_ch);

  1410.         int num_coeffs = av_popcount(mix_map_mask);

  1411.         skip_bits_long(gb, num_coeffs * 6);

  1412.     }

  1413. }

  1414. 

  1415. /**

  1416.  * Parse extension substream asset header (HD)

  1417.  */

  1418. static int dca_exss_parse_asset_header(DCAContext *s)

  1419. {

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

  1421.     int header_size;

  1422.     int channels;

  1423.     int embedded_stereo = 0;

  1424.     int embedded_6ch    = 0;

  1425.     int drc_code_present;

  1426.     int extensions_mask;

  1427.     int i, j;

  1428. 

  1429.     if (get_bits_left(&s->gb) < 16)

  1430.         return -1;

  1431. 

  1432.     /* We will parse just enough to get to the extensions bitmask with which

  1433.      * we can set the profile value. */

  1434. 

  1435.     header_size = get_bits(&s->gb, 9) + 1;

  1436.     skip_bits(&s->gb, 3); // asset index

  1437. 

  1438.     if (s->static_fields) {

  1439.         if (get_bits1(&s->gb))

  1440.             skip_bits(&s->gb, 4); // asset type descriptor

  1441.         if (get_bits1(&s->gb))

  1442.             skip_bits_long(&s->gb, 24); // language descriptor

  1443. 

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

  1445.             /* How can one fit 1024 bytes of text here if the maximum value

  1446.              * for the asset header size field above was 512 bytes? */

  1447.             int text_length = get_bits(&s->gb, 10) + 1;

  1448.             if (get_bits_left(&s->gb) < text_length * 8)

  1449.                 return -1;

  1450.             skip_bits_long(&s->gb, text_length * 8); // info text

  1451.         }

  1452. 

  1453.         skip_bits(&s->gb, 5); // bit resolution - 1

  1454.         skip_bits(&s->gb, 4); // max sample rate code

  1455.         channels = get_bits(&s->gb, 8) + 1;

  1456. 

  1457.         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers

  1458.             int spkr_remap_sets;

  1459.             int spkr_mask_size = 16;

  1460.             int num_spkrs[7];

  1461. 

  1462.             if (channels > 2)

  1463.                 embedded_stereo = get_bits1(&s->gb);

  1464.             if (channels > 6)

  1465.                 embedded_6ch = get_bits1(&s->gb);

  1466. 

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

  1468.                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;

  1469.                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask

  1470.             }

  1471. 

  1472.             spkr_remap_sets = get_bits(&s->gb, 3);

  1473. 

  1474.             for (i = 0; i < spkr_remap_sets; i++) {

  1475.                 /* std layout mask for each remap set */

  1476.                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));

  1477.             }

  1478. 

  1479.             for (i = 0; i < spkr_remap_sets; i++) {

  1480.                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;

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

  1482.                     return -1;

  1483. 

  1484.                 for (j = 0; j < num_spkrs[i]; j++) {

  1485.                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);

  1486.                     int num_dec_ch = av_popcount(remap_dec_ch_mask);

  1487.                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes

  1488.                 }

  1489.             }

  1490. 

  1491.         } else {

  1492.             skip_bits(&s->gb, 3); // representation type

  1493.         }

  1494.     }

  1495. 

  1496.     drc_code_present = get_bits1(&s->gb);

  1497.     if (drc_code_present)

  1498.         get_bits(&s->gb, 8); // drc code

  1499. 

  1500.     if (get_bits1(&s->gb))

  1501.         skip_bits(&s->gb, 5); // dialog normalization code

  1502. 

  1503.     if (drc_code_present && embedded_stereo)

  1504.         get_bits(&s->gb, 8); // drc stereo code

  1505. 

  1506.     if (s->mix_metadata && get_bits1(&s->gb)) {

  1507.         skip_bits(&s->gb, 1); // external mix

  1508.         skip_bits(&s->gb, 6); // post mix gain code

  1509. 

  1510.         if (get_bits(&s->gb, 2) != 3) // mixer drc code

  1511.             skip_bits(&s->gb, 3); // drc limit

  1512.         else

  1513.             skip_bits(&s->gb, 8); // custom drc code

  1514. 

  1515.         if (get_bits1(&s->gb)) // channel specific scaling

  1516.             for (i = 0; i < s->num_mix_configs; i++)

  1517.                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes

  1518.         else

  1519.             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes

  1520. 

  1521.         for (i = 0; i < s->num_mix_configs; i++) {

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

  1523.                 return -1;

  1524.             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);

  1525.             if (embedded_6ch)

  1526.                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);

  1527.             if (embedded_stereo)

  1528.                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);

  1529.         }

  1530.     }

  1531. 

  1532.     switch (get_bits(&s->gb, 2)) {

  1533.     case 0: extensions_mask = get_bits(&s->gb, 12); break;

  1534.     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;

  1535.     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;

  1536.     case 3: extensions_mask = 0; /* aux coding */   break;

  1537.     }

  1538. 

  1539.     /* not parsed further, we were only interested in the extensions mask */

  1540. 

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

  1542.         return -1;

  1543. 

  1544.     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {

  1545.         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");

  1546.         return -1;

  1547.     }

  1548.     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));

  1549. 

  1550.     if (extensions_mask & DCA_EXT_EXSS_XLL)

  1551.         s->profile = FF_PROFILE_DTS_HD_MA;

  1552.     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |

  1553.                                 DCA_EXT_EXSS_XXCH))

  1554.         s->profile = FF_PROFILE_DTS_HD_HRA;

  1555. 

  1556.     if (!(extensions_mask & DCA_EXT_CORE))

  1557.         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");

  1558.     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)

  1559.         av_log(s->avctx, AV_LOG_WARNING,

  1560.                "DTS extensions detection mismatch (%d, %d)\n",

  1561.                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);

  1562. 

  1563.     return 0;

  1564. }

  1565. 

  1566. /**

  1567.  * Parse extension substream header (HD)

  1568.  */

  1569. static void dca_exss_parse_header(DCAContext *s)

  1570. {

  1571.     int ss_index;

  1572.     int blownup;

  1573.     int num_audiop = 1;

  1574.     int num_assets = 1;

  1575.     int active_ss_mask[8];

  1576.     int i, j;

  1577. 

  1578.     if (get_bits_left(&s->gb) < 52)

  1579.         return;

  1580. 

  1581.     skip_bits(&s->gb, 8); // user data

  1582.     ss_index = get_bits(&s->gb, 2);

  1583. 

  1584.     blownup = get_bits1(&s->gb);

  1585.     skip_bits(&s->gb,  8 + 4 * blownup); // header_size

  1586.     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size

  1587. 

  1588.     s->static_fields = get_bits1(&s->gb);

  1589.     if (s->static_fields) {

  1590.         skip_bits(&s->gb, 2); // reference clock code

  1591.         skip_bits(&s->gb, 3); // frame duration code

  1592. 

  1593.         if (get_bits1(&s->gb))

  1594.             skip_bits_long(&s->gb, 36); // timestamp

  1595. 

  1596.         /* a single stream can contain multiple audio assets that can be

  1597.          * combined to form multiple audio presentations */

  1598. 

  1599.         num_audiop = get_bits(&s->gb, 3) + 1;

  1600.         if (num_audiop > 1) {

  1601.             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");

  1602.             /* ignore such streams for now */

  1603.             return;

  1604.         }

  1605. 

  1606.         num_assets = get_bits(&s->gb, 3) + 1;

  1607.         if (num_assets > 1) {

  1608.             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");

  1609.             /* ignore such streams for now */

  1610.             return;

  1611.         }

  1612. 

  1613.         for (i = 0; i < num_audiop; i++)

  1614.             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);

  1615. 

  1616.         for (i = 0; i < num_audiop; i++)

  1617.             for (j = 0; j <= ss_index; j++)

  1618.                 if (active_ss_mask[i] & (1 << j))

  1619.                     skip_bits(&s->gb, 8); // active asset mask

  1620. 

  1621.         s->mix_metadata = get_bits1(&s->gb);

  1622.         if (s->mix_metadata) {

  1623.             int mix_out_mask_size;

  1624. 

  1625.             skip_bits(&s->gb, 2); // adjustment level

  1626.             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;

  1627.             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;

  1628. 

  1629.             for (i = 0; i < s->num_mix_configs; i++) {

  1630.                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);

  1631.                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);

  1632.             }

  1633.         }

  1634.     }

  1635. 

  1636.     for (i = 0; i < num_assets; i++)

  1637.         skip_bits_long(&s->gb, 16 + 4 * blownup);  // asset size

  1638. 

  1639.     for (i = 0; i < num_assets; i++) {

  1640.         if (dca_exss_parse_asset_header(s))

  1641.             return;

  1642.     }

  1643. 

  1644.     /* not parsed further, we were only interested in the extensions mask

  1645.      * from the asset header */

  1646. }

  1647. 

  1648. /**

  1649.  * Main frame decoding function

  1650.  * FIXME add arguments

  1651.  */

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

  1653.                             int *got_frame_ptr, AVPacket *avpkt)

  1654. {

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

  1656.     int buf_size = avpkt->size;

  1657. 

  1658.     int lfe_samples;

  1659.     int num_core_channels = 0;

  1660.     int i, ret;

  1661.     float  **samples_flt;

  1662.     DCAContext *s = avctx->priv_data;

  1663.     int channels, full_channels;

  1664.     int core_ss_end;

  1665. 

  1666. 

  1667.     s->xch_present = 0;

  1668. 

  1669.     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,

  1670.                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);

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

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

  1673.         return AVERROR_INVALIDDATA;

  1674.     }

  1675. 

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

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

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

  1679.         return ret;

  1680.     }

  1681.     //set AVCodec values with parsed data

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

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

  1684. 

  1685.     s->profile = FF_PROFILE_DTS;

  1686. 

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

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

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

  1690.             return ret;

  1691.         }

  1692.     }

  1693. 

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

  1695.     num_core_channels = s->prim_channels;

  1696. 

  1697.     if (s->ext_coding)

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

  1699.     else

  1700.         s->core_ext_mask = 0;

  1701. 

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

  1703. 

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

  1705.      * supported XCh extension */

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

  1707. 

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

  1709.          * extensions scan can fill it up */

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

  1711. 

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

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

  1714. 

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

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

  1717. 

  1718.             switch (bits) {

  1719.             case 0x5a5a5a5a: {

  1720.                 int ext_amode, xch_fsize;

  1721. 

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

  1723. 

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

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

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

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

  1728.                     continue;

  1729. 

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

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

  1732. 

  1733.                 s->core_ext_mask |= DCA_EXT_XCH;

  1734. 

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

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

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

  1738.                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"

  1739.                            " supported!\n", ext_amode);

  1740.                     continue;

  1741.                 }

  1742. 

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

  1744.                 dca_parse_audio_coding_header(s, s->xch_base_channel);

  1745. 

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

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

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

  1749.                         continue;

  1750.                     }

  1751. 

  1752.                 s->xch_present = 1;

  1753.                 break;

  1754.             }

  1755.             case 0x47004a03:

  1756.                 /* XXCh: extended channels */

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

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

  1759.                 s->core_ext_mask |= DCA_EXT_XXCH;

  1760.                 break;

  1761. 

  1762.             case 0x1d95f262: {

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

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

  1765.                     continue;

  1766. 

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

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

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

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

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

  1772. 

  1773.                 s->core_ext_mask |= DCA_EXT_X96;

  1774.                 break;

  1775.             }

  1776.             }

  1777. 

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

  1779.         }

  1780.     } else {

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

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

  1783.     }

  1784. 

  1785.     if (s->core_ext_mask & DCA_EXT_X96)

  1786.         s->profile = FF_PROFILE_DTS_96_24;

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

  1788.         s->profile = FF_PROFILE_DTS_ES;

  1789. 

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

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

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

  1793.         dca_exss_parse_header(s);

  1794. 

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

  1796. 

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

  1798. 

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

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

  1801. 

  1802.         if (s->xch_present && (!avctx->request_channels ||

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

  1804.             avctx->channel_layout |= AV_CH_BACK_CENTER;

  1805.             if (s->lfe) {

  1806.                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;

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

  1808.             } else {

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

  1810.             }

  1811.         } else {

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

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

  1814.             if (s->lfe) {

  1815.                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;

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

  1817.             } else

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

  1819.         }

  1820. 

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

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

  1823.             return AVERROR_INVALIDDATA;

  1824. 

  1825.         if (avctx->request_channels == 2 && s->prim_channels > 2) {

  1826.             channels = 2;

  1827.             s->output = DCA_STEREO;

  1828.             avctx->channel_layout = AV_CH_LAYOUT_STEREO;

  1829.         }

  1830.     } else {

  1831.         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);

  1832.         return AVERROR_INVALIDDATA;

  1833.     }

  1834. 

  1835. 

  1836.     /* There is nothing that prevents a dts frame to change channel configuration

  1837.        but Libav doesn't support that so only set the channels if it is previously

  1838.        unset. Ideally during the first probe for channels the crc should be checked

  1839.        and only set avctx->channels when the crc is ok. Right now the decoder could

  1840.        set the channels based on a broken first frame.*/

  1841.     if (s->is_channels_set == 0) {

  1842.         s->is_channels_set = 1;

  1843.         avctx->channels = channels;

  1844.     }

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

  1846.         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "

  1847.                "channels changing in stream. Skipping frame.\n");

  1848.         return AVERROR_PATCHWELCOME;

  1849.     }

  1850. 

  1851.     /* get output buffer */

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

  1853.     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {

  1854.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1855.         return ret;

  1856.     }

  1857.     samples_flt = (float  **) s->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.                                          s->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.                                      s->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. 

  1902.     /* update lfe history */

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

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

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

  1906. 

  1907.     *got_frame_ptr    = 1;

  1908.     *(AVFrame *) data = s->frame;

  1909. 

  1910.     return buf_size;

  1911. }

  1912. 

  1913. 

  1914. 

  1915. /**

  1916.  * DCA initialization

  1917.  *

  1918.  * @param avctx     pointer to the AVCodecContext

  1919.  */

  1920. 

  1921. static av_cold int dca_decode_init(AVCodecContext *avctx)

  1922. {

  1923.     DCAContext *s = avctx->priv_data;

  1924. 

  1925.     s->avctx = avctx;

  1926.     dca_init_vlcs();

  1927. 

  1928.     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);

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

  1930.     ff_synth_filter_init(&s->synth);

  1931.     ff_dcadsp_init(&s->dcadsp);

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

  1933. 

  1934.     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

  1935. 

  1936.     /* allow downmixing to stereo */

  1937.     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&

  1938.         avctx->request_channels == 2) {

  1939.         avctx->channels = avctx->request_channels;

  1940.     }

  1941. 

  1942.     avcodec_get_frame_defaults(&s->frame);

  1943.     avctx->coded_frame = &s->frame;

  1944. 

  1945.     return 0;

  1946. }

  1947. 

  1948. static av_cold int dca_decode_end(AVCodecContext *avctx)

  1949. {

  1950.     DCAContext *s = avctx->priv_data;

  1951.     ff_mdct_end(&s->imdct);

  1952.     av_freep(&s->extra_channels_buffer);

  1953.     return 0;

  1954. }

  1955. 

  1956. static const AVProfile profiles[] = {

  1957.     { FF_PROFILE_DTS,        "DTS"        },

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

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

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

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

  1962.     { FF_PROFILE_UNKNOWN },

  1963. };

  1964. 

  1965. AVCodec ff_dca_decoder = {

  1966.     .name            = "dca",

  1967.     .type            = AVMEDIA_TYPE_AUDIO,

  1968.     .id              = AV_CODEC_ID_DTS,

  1969.     .priv_data_size  = sizeof(DCAContext),

  1970.     .init            = dca_decode_init,

  1971.     .decode          = dca_decode_frame,

  1972.     .close           = dca_decode_end,

  1973.     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

  1974.     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,

  1975.     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

  1976.                                                        AV_SAMPLE_FMT_NONE },

  1977.     .profiles        = NULL_IF_CONFIG_SMALL(profiles),

  1978. };