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.
20536 Commits
32 Branches
283MB
Tree: b01c7b756e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b01c7b756e'
${ noResults }
FFmpeg/libavcodec/dca.c

1362 lines
49KB
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. /**

  26.  * @file libavcodec/dca.c

  27.  */

  28. 

  29. #include <math.h>

  30. #include <stddef.h>

  31. #include <stdio.h>

  32. 

  33. #include "avcodec.h"

  34. #include "dsputil.h"

  35. #include "get_bits.h"

  36. #include "put_bits.h"

  37. #include "dcadata.h"

  38. #include "dcahuff.h"

  39. #include "dca.h"

  40. 

  41. //#define TRACE

  42. 

  43. #define DCA_PRIM_CHANNELS_MAX (5)

  44. #define DCA_SUBBANDS (32)

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

  46. #define DCA_SUBSUBFAMES_MAX (4)

  47. #define DCA_LFE_MAX (3)

  48. 

  49. enum DCAMode {

  50.     DCA_MONO = 0,

  51.     DCA_CHANNEL,

  52.     DCA_STEREO,

  53.     DCA_STEREO_SUMDIFF,

  54.     DCA_STEREO_TOTAL,

  55.     DCA_3F,

  56.     DCA_2F1R,

  57.     DCA_3F1R,

  58.     DCA_2F2R,

  59.     DCA_3F2R,

  60.     DCA_4F2R

  61. };

  62. 

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

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

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

  66.  *

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

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

  69.  * OV -> center back

  70.  * All 2 channel configurations -> CH_LAYOUT_STEREO

  71.  */

  72. 

  73. static const int64_t dca_core_channel_layout[] = {

  74.     CH_FRONT_CENTER,                                               ///< 1, A

  75.     CH_LAYOUT_STEREO,                                              ///< 2, A + B (dual mono)

  76.     CH_LAYOUT_STEREO,                                              ///< 2, L + R (stereo)

  77.     CH_LAYOUT_STEREO,                                              ///< 2, (L+R) + (L-R) (sum-difference)

  78.     CH_LAYOUT_STEREO,                                              ///< 2, LT +RT (left and right total)

  79.     CH_LAYOUT_STEREO|CH_FRONT_CENTER,                              ///< 3, C+L+R

  80.     CH_LAYOUT_STEREO|CH_BACK_CENTER,                               ///< 3, L+R+S

  81.     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,               ///< 4, C + L + R+ S

  82.     CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,                   ///< 4, L + R +SL+ SR

  83.     CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,   ///< 5, C + L + R+ SL+SR

  84.     CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER,                 ///< 6, CL + CR + L + R + SL + SR

  85.     CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,                                   ///< 6, C + L + R+ LR + RR + OV

  86.     CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT,   ///< 6, CF+ CR+LF+ RF+LR + RR

  87.     CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT, ///< 7, CL + C + CR + L + R + SL + SR

  88.     CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT, ///< 8, CL + CR + L + R + SL1 + SL2+ SR1 + SR2

  89.     CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT, ///< 8, CL + C+ CR + L + R + SL + S+ SR

  90. };

  91. 

  92. static const int8_t dca_lfe_index[] = {

  93.     1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3

  94. };

  95. 

  96. static const int8_t dca_channel_reorder_lfe[][8] = {

  97.     { 0, -1, -1, -1, -1, -1, -1, -1},

  98.     { 0,  1, -1, -1, -1, -1, -1, -1},

  99.     { 0,  1, -1, -1, -1, -1, -1, -1},

  100.     { 0,  1, -1, -1, -1, -1, -1, -1},

  101.     { 0,  1, -1, -1, -1, -1, -1, -1},

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

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

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

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

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

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

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

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

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

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

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

  113. };

  114. 

  115. static const int8_t dca_channel_reorder_nolfe[][8] = {

  116.     { 0, -1, -1, -1, -1, -1, -1, -1},

  117.     { 0,  1, -1, -1, -1, -1, -1, -1},

  118.     { 0,  1, -1, -1, -1, -1, -1, -1},

  119.     { 0,  1, -1, -1, -1, -1, -1, -1},

  120.     { 0,  1, -1, -1, -1, -1, -1, -1},

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

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

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

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

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

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

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

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

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

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

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

  132. };

  133. 

  134. 

  135. #define DCA_DOLBY 101           /* FIXME */

  136. 

  137. #define DCA_CHANNEL_BITS 6

  138. #define DCA_CHANNEL_MASK 0x3F

  139. 

  140. #define DCA_LFE 0x80

  141. 

  142. #define HEADER_SIZE 14

  143. 

  144. #define DCA_MAX_FRAME_SIZE 16384

  145. 

  146. /** Bit allocation */

  147. typedef struct {

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

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

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

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

  152. } BitAlloc;

  153. 

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

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

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

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

  158. 

  159. static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)

  160. {

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

  162. }

  163. 

  164. typedef struct {

  165.     AVCodecContext *avctx;

  166.     /* Frame header */

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

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

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

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

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

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

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

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

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

  176. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  190.     int copy_history;           ///< copy history

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

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

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

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

  195. 

  196.     /* Primary audio coding header */

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

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

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

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

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

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

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

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

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

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

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

  208. 

  209.     /* Primary audio coding side information */

  210.     int subsubframes;           ///< number of subsubframes

  211.     int partial_samples;        ///< partial subsubframe samples count

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

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

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

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

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

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

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

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

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

  221. 

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

  223. 

  224.     float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *

  225.                    2 /*history */ ];    ///< Low frequency effect data

  226.     int lfe_scale_factor;

  227. 

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

  229.     float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];

  230.     DECLARE_ALIGNED_16(float, subband_fir_hist[DCA_PRIM_CHANNELS_MAX][512]);

  231.     float subband_fir_noidea[DCA_PRIM_CHANNELS_MAX][32];

  232.     int hist_index[DCA_PRIM_CHANNELS_MAX];

  233. 

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

  235.     float add_bias;             ///< output bias

  236.     float scale_bias;           ///< output scale

  237. 

  238.     DECLARE_ALIGNED_16(float, samples[1536]);  /* 6 * 256 = 1536, might only need 5 */

  239.     const float *samples_chanptr[6];

  240. 

  241.     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];

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

  243. 

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

  245.     GetBitContext gb;

  246.     /* Current position in DCA frame */

  247.     int current_subframe;

  248.     int current_subsubframe;

  249. 

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

  251.     DSPContext dsp;

  252.     MDCTContext imdct;

  253. } DCAContext;

  254. 

  255. static const uint16_t dca_vlc_offs[] = {

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

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

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

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

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

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

  262. };

  263. 

  264. static av_cold void dca_init_vlcs(void)

  265. {

  266.     static int vlcs_initialized = 0;

  267.     int i, j, c = 14;

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

  269. 

  270.     if (vlcs_initialized)

  271.         return;

  272. 

  273.     dca_bitalloc_index.offset = 1;

  274.     dca_bitalloc_index.wrap = 2;

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

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

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

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

  279.                  bitalloc_12_bits[i], 1, 1,

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

  281.     }

  282.     dca_scalefactor.offset = -64;

  283.     dca_scalefactor.wrap = 2;

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

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

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

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

  288.                  scales_bits[i], 1, 1,

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

  290.     }

  291.     dca_tmode.offset = 0;

  292.     dca_tmode.wrap = 1;

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

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

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

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

  297.                  tmode_bits[i], 1, 1,

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

  299.     }

  300. 

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

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

  303.             if(!bitalloc_codes[i][j]) break;

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

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

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

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

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

  309.                      bitalloc_sizes[i],

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

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

  312.             c++;

  313.         }

  314.     vlcs_initialized = 1;

  315. }

  316. 

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

  318. {

  319.     while(len--)

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

  321. }

  322. 

  323. static int dca_parse_frame_header(DCAContext * s)

  324. {

  325.     int i, j;

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

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

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

  329. 

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

  331. 

  332.     /* Sync code */

  333.     get_bits(&s->gb, 32);

  334. 

  335.     /* Frame header */

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

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

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

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

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

  341.     if (s->frame_size < 95)

  342.         return -1;

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

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

  345.     if (!s->sample_rate)

  346.         return -1;

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

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

  349.     if (!s->bit_rate)

  350.         return -1;

  351. 

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

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

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

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

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

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

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

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

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

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

  362. 

  363.     /* TODO: check CRC */

  364.     if (s->crc_present)

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

  366. 

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

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

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

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

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

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

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

  374. 

  375.     /* FIXME: channels mixing levels */

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

  377.     if(s->lfe) s->output |= DCA_LFE;

  378. 

  379. #ifdef TRACE

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

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

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

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

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

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

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

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

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

  389.            s->sample_rate);

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

  391.            s->bit_rate);

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

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

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

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

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

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

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

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

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

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

  402.            s->predictor_history);

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

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

  405.            s->multirate_inter);

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

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

  408.     av_log(s->avctx, AV_LOG_DEBUG,

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

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

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

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

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

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

  415. #endif

  416. 

  417.     /* Primary audio coding header */

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

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

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

  421.     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)

  422.         s->prim_channels = DCA_PRIM_CHANNELS_MAX;   /* We only support DTS core */

  423. 

  424. 

  425.     for (i = 0; i < s->prim_channels; i++) {

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

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

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

  429.     }

  430.     for (i = 0; i < s->prim_channels; i++) {

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

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

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

  434.     }

  435.     get_array(&s->gb, s->joint_intensity,     s->prim_channels, 3);

  436.     get_array(&s->gb, s->transient_huffman,   s->prim_channels, 2);

  437.     get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);

  438.     get_array(&s->gb, s->bitalloc_huffman,    s->prim_channels, 3);

  439. 

  440.     /* Get codebooks quantization indexes */

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

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

  443.         for (i = 0; i < s->prim_channels; i++)

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

  445. 

  446.     /* Get scale factor adjustment */

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

  448.         for (i = 0; i < s->prim_channels; i++)

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

  450. 

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

  452.         for (i = 0; i < s->prim_channels; i++)

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

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

  455. 

  456.     if (s->crc_present) {

  457.         /* Audio header CRC check */

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

  459.     }

  460. 

  461.     s->current_subframe = 0;

  462.     s->current_subsubframe = 0;

  463. 

  464. #ifdef TRACE

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

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

  467.     for(i = 0; i < s->prim_channels; i++){

  468.         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);

  469.         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);

  470.         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);

  471.         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);

  472.         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);

  473.         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);

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

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

  476.             av_log(s->avctx, AV_LOG_DEBUG, " %i",

  477.                    s->quant_index_huffman[i][j]);

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

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

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

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

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

  483.     }

  484. #endif

  485. 

  486.     return 0;

  487. }

  488. 

  489. 

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

  491. {

  492.    if (level < 5) {

  493.        /* huffman encoded */

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

  495.    } else if(level < 8)

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

  497.    return value;

  498. }

  499. 

  500. static int dca_subframe_header(DCAContext * s)

  501. {

  502.     /* Primary audio coding side information */

  503.     int j, k;

  504. 

  505.     s->subsubframes = get_bits(&s->gb, 2) + 1;

  506.     s->partial_samples = get_bits(&s->gb, 3);

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

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

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

  510.     }

  511. 

  512.     /* Get prediction codebook */

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

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

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

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

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

  518.             }

  519.         }

  520.     }

  521. 

  522.     /* Bit allocation index */

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

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

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

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

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

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

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

  530.                 av_log(s->avctx, AV_LOG_ERROR,

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

  532.                 return -1;

  533.             } else {

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

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

  536.             }

  537. 

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

  539. //                 av_log(s->avctx,AV_LOG_DEBUG,"bitalloc index [%i][%i] too big (%i)\n",

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

  541.                 return -1;

  542.             }

  543.         }

  544.     }

  545. 

  546.     /* Transition mode */

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

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

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

  550.             if (s->subsubframes > 1 &&

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

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

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

  554.             }

  555.         }

  556.     }

  557. 

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

  559.         const uint32_t *scale_table;

  560.         int scale_sum;

  561. 

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

  563. 

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

  565.             scale_table = scale_factor_quant7;

  566.         else

  567.             scale_table = scale_factor_quant6;

  568. 

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

  570.         scale_sum = 0;

  571. 

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

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

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

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

  576.             }

  577. 

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

  579.                 /* Get second scale factor */

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

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

  582.             }

  583.         }

  584.     }

  585. 

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

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

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

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

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

  591.     }

  592. 

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

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

  595.         int source_channel;

  596. 

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

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

  599.             int scale = 0;

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

  601. 

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

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

  604. 

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

  606.                 scale = get_scale(&s->gb, s->joint_huff[j], 0);

  607.                 scale += 64;    /* bias */

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

  609.             }

  610. 

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

  612.                 av_log(s->avctx, AV_LOG_DEBUG,

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

  614.                 s->debug_flag |= 0x02;

  615.             }

  616.         }

  617.     }

  618. 

  619.     /* Stereo downmix coefficients */

  620.     if (s->prim_channels > 2) {

  621.         if(s->downmix) {

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

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

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

  625.             }

  626.         } else {

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

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

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

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

  631.             }

  632.         }

  633.     }

  634. 

  635.     /* Dynamic range coefficient */

  636.     if (s->dynrange)

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

  638. 

  639.     /* Side information CRC check word */

  640.     if (s->crc_present) {

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

  642.     }

  643. 

  644.     /*

  645.      * Primary audio data arrays

  646.      */

  647. 

  648.     /* VQ encoded high frequency subbands */

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

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

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

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

  653. 

  654.     /* Low frequency effect data */

  655.     if (s->lfe) {

  656.         /* LFE samples */

  657.         int lfe_samples = 2 * s->lfe * s->subsubframes;

  658.         float lfe_scale;

  659. 

  660.         for (j = lfe_samples; j < lfe_samples * 2; j++) {

  661.             /* Signed 8 bits int */

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

  663.         }

  664. 

  665.         /* Scale factor index */

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

  667. 

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

  669.         lfe_scale = 0.035 * s->lfe_scale_factor;

  670. 

  671.         for (j = lfe_samples; j < lfe_samples * 2; j++)

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

  673.     }

  674. 

  675. #ifdef TRACE

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

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

  678.            s->partial_samples);

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

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

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

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

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

  684.     }

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

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

  687.                 av_log(s->avctx, AV_LOG_DEBUG,

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

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

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

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

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

  693.     }

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

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

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

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

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

  699.     }

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

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

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

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

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

  705.     }

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

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

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

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

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

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

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

  713.         }

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

  715.     }

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

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

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

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

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

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

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

  723.         }

  724.     }

  725.     if (s->prim_channels > 2 && s->downmix) {

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

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

  728.             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);

  729.             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);

  730.         }

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

  732.     }

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

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

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

  736.     if(s->lfe){

  737.         int lfe_samples = 2 * s->lfe * s->subsubframes;

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

  739.         for (j = lfe_samples; j < lfe_samples * 2; j++)

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

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

  742.     }

  743. #endif

  744. 

  745.     return 0;

  746. }

  747. 

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

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

  750.                             float scale, float bias)

  751. {

  752.     const float *prCoeff;

  753.     int i, j;

  754.     DECLARE_ALIGNED_16(float, raXin[32]);

  755. 

  756.     int hist_index= s->hist_index[chans];

  757.     float *subband_fir_hist2 = s->subband_fir_noidea[chans];

  758. 

  759.     int subindex;

  760. 

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

  762. 

  763.     /* Select filter */

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

  765.         prCoeff = fir_32bands_nonperfect;

  766.     else                        /* Perfect reconstruction */

  767.         prCoeff = fir_32bands_perfect;

  768. 

  769.     /* Reconstructed channel sample index */

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

  771.         float *subband_fir_hist = s->subband_fir_hist[chans] + hist_index;

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

  773.         for (i = 0; i < s->subband_activity[chans]; i++){

  774.             if((i-1)&2) raXin[i] = -samples_in[i][subindex];

  775.             else        raXin[i] =  samples_in[i][subindex];

  776.         }

  777.         for (; i < 32; i++)

  778.             raXin[i] = 0.0;

  779. 

  780.         ff_imdct_half(&s->imdct, subband_fir_hist, raXin);

  781. 

  782.         /* Multiply by filter coefficients */

  783.         for (i = 0; i < 16; i++){

  784.             float a= subband_fir_hist2[i   ];

  785.             float b= subband_fir_hist2[i+16];

  786.             float c= 0;

  787.             float d= 0;

  788.             for (j = 0; j < 512-hist_index; j += 64){

  789.                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j]);

  790.                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j]);

  791.                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j]);

  792.                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j]);

  793.             }

  794.             for (     ; j < 512; j += 64){

  795.                 a += prCoeff[i+j   ]*(-subband_fir_hist[15-i+j-512]);

  796.                 b += prCoeff[i+j+16]*( subband_fir_hist[   i+j-512]);

  797.                 c += prCoeff[i+j+32]*( subband_fir_hist[16+i+j-512]);

  798.                 d += prCoeff[i+j+48]*( subband_fir_hist[31-i+j-512]);

  799.             }

  800.             samples_out[i   ] = a * scale + bias;

  801.             samples_out[i+16] = b * scale + bias;

  802.             subband_fir_hist2[i   ] = c;

  803.             subband_fir_hist2[i+16] = d;

  804.         }

  805.         samples_out+= 32;

  806. 

  807.         hist_index = (hist_index-32)&511;

  808.     }

  809.     s->hist_index[chans]= hist_index;

  810. }

  811. 

  812. static void lfe_interpolation_fir(int decimation_select,

  813.                                   int num_deci_sample, float *samples_in,

  814.                                   float *samples_out, float scale,

  815.                                   float bias)

  816. {

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

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

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

  820.      *   from last subframe as history.

  821.      *

  822.      * samples_out: An array holding interpolated samples

  823.      */

  824. 

  825.     int decifactor, k, j;

  826.     const float *prCoeff;

  827. 

  828.     int interp_index = 0;       /* Index to the interpolated samples */

  829.     int deciindex;

  830. 

  831.     /* Select decimation filter */

  832.     if (decimation_select == 1) {

  833.         decifactor = 128;

  834.         prCoeff = lfe_fir_128;

  835.     } else {

  836.         decifactor = 64;

  837.         prCoeff = lfe_fir_64;

  838.     }

  839.     /* Interpolation */

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

  841.         /* One decimated sample generates decifactor interpolated ones */

  842.         for (k = 0; k < decifactor; k++) {

  843.             float rTmp = 0.0;

  844.             //FIXME the coeffs are symetric, fix that

  845.             for (j = 0; j < 512 / decifactor; j++)

  846.                 rTmp += samples_in[deciindex - j] * prCoeff[k + j * decifactor];

  847.             samples_out[interp_index++] = (rTmp * scale) + bias;

  848.         }

  849.     }

  850. }

  851. 

  852. /* downmixing routines */

  853. #define MIX_REAR1(samples, si1, rs, coef) \

  854.      samples[i]     += samples[si1] * coef[rs][0]; \

  855.      samples[i+256] += samples[si1] * coef[rs][1];

  856. 

  857. #define MIX_REAR2(samples, si1, si2, rs, coef) \

  858.      samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \

  859.      samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];

  860. 

  861. #define MIX_FRONT3(samples, coef) \

  862.     t = samples[i]; \

  863.     samples[i]     = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \

  864.     samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];

  865. 

  866. #define DOWNMIX_TO_STEREO(op1, op2) \

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

  868.         op1 \

  869.         op2 \

  870.     }

  871. 

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

  873.                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])

  874. {

  875.     int i;

  876.     float t;

  877.     float coef[DCA_PRIM_CHANNELS_MAX][2];

  878. 

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

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

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

  882.     }

  883. 

  884.     switch (srcfmt) {

  885.     case DCA_MONO:

  886.     case DCA_CHANNEL:

  887.     case DCA_STEREO_TOTAL:

  888.     case DCA_STEREO_SUMDIFF:

  889.     case DCA_4F2R:

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

  891.         break;

  892.     case DCA_STEREO:

  893.         break;

  894.     case DCA_3F:

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

  896.         break;

  897.     case DCA_2F1R:

  898.         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);

  899.         break;

  900.     case DCA_3F1R:

  901.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

  902.                           MIX_REAR1(samples, i + 768, 3, coef));

  903.         break;

  904.     case DCA_2F2R:

  905.         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);

  906.         break;

  907.     case DCA_3F2R:

  908.         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),

  909.                           MIX_REAR2(samples, i + 768, i + 1024, 3, coef));

  910.         break;

  911.     }

  912. }

  913. 

  914. 

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

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

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

  918. {

  919.     int i;

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

  921. 

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

  923.         values[i] = (code % levels) - offset;

  924.         code /= levels;

  925.     }

  926. 

  927.     if (code == 0)

  928.         return 0;

  929.     else {

  930.         av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");

  931.         return -1;

  932.     }

  933. }

  934. 

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

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

  937. 

  938. static int dca_subsubframe(DCAContext * s)

  939. {

  940.     int k, l;

  941.     int subsubframe = s->current_subsubframe;

  942. 

  943.     const float *quant_step_table;

  944. 

  945.     /* FIXME */

  946.     float subband_samples[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];

  947. 

  948.     /*

  949.      * Audio data

  950.      */

  951. 

  952.     /* Select quantization step size table */

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

  954.         quant_step_table = lossless_quant_d;

  955.     else

  956.         quant_step_table = lossy_quant_d;

  957. 

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

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

  960.             int m;

  961. 

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

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

  964. 

  965.             float quant_step_size = quant_step_table[abits];

  966.             float rscale;

  967. 

  968.             /*

  969.              * Determine quantization index code book and its type

  970.              */

  971. 

  972.             /* Select quantization index code book */

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

  974. 

  975.             /*

  976.              * Extract bits from the bit stream

  977.              */

  978.             if(!abits){

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

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

  981.                 if(abits <= 7){

  982.                     /* Block code */

  983.                     int block_code1, block_code2, size, levels;

  984.                     int block[8];

  985. 

  986.                     size = abits_sizes[abits-1];

  987.                     levels = abits_levels[abits-1];

  988. 

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

  990.                     /* FIXME Should test return value */

  991.                     decode_blockcode(block_code1, levels, block);

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

  993.                     decode_blockcode(block_code2, levels, &block[4]);

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

  995.                         subband_samples[k][l][m] = block[m];

  996.                 }else{

  997.                     /* no coding */

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

  999.                         subband_samples[k][l][m] = get_sbits(&s->gb, abits - 3);

  1000.                 }

  1001.             }else{

  1002.                 /* Huffman coded */

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

  1004.                     subband_samples[k][l][m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);

  1005.             }

  1006. 

  1007.             /* Deal with transients */

  1008.             if (s->transition_mode[k][l] &&

  1009.                 subsubframe >= s->transition_mode[k][l])

  1010.                 rscale = quant_step_size * s->scale_factor[k][l][1];

  1011.             else

  1012.                 rscale = quant_step_size * s->scale_factor[k][l][0];

  1013. 

  1014.             rscale *= s->scalefactor_adj[k][sel];

  1015. 

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

  1017.                 subband_samples[k][l][m] *= rscale;

  1018. 

  1019.             /*

  1020.              * Inverse ADPCM if in prediction mode

  1021.              */

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

  1023.                 int n;

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

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

  1026.                         if (m >= n)

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

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

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

  1030.                         else if (s->predictor_history)

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

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

  1033.                                  s->subband_samples_hist[k][l][m - n +

  1034.                                                                4] / 8192);

  1035.                 }

  1036.             }

  1037.         }

  1038. 

  1039.         /*

  1040.          * Decode VQ encoded high frequencies

  1041.          */

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

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

  1044.              * for this subsubframe. */

  1045.             int m;

  1046. 

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

  1048.                 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");

  1049.                 s->debug_flag |= 0x01;

  1050.             }

  1051. 

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

  1053.                 subband_samples[k][l][m] =

  1054.                     high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +

  1055.                                                         m]

  1056.                     * (float) s->scale_factor[k][l][0] / 16.0;

  1057.             }

  1058.         }

  1059.     }

  1060. 

  1061.     /* Check for DSYNC after subsubframe */

  1062.     if (s->aspf || subsubframe == s->subsubframes - 1) {

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

  1064. #ifdef TRACE

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

  1066. #endif

  1067.         } else {

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

  1069.         }

  1070.     }

  1071. 

  1072.     /* Backup predictor history for adpcm */

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

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

  1075.             memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],

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

  1077. 

  1078.     /* 32 subbands QMF */

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

  1080. /*        static float pcm_to_double[8] =

  1081.             {32768.0, 32768.0, 524288.0, 524288.0, 0, 8388608.0, 8388608.0};*/

  1082.          qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],

  1083.                             M_SQRT1_2*s->scale_bias /*pcm_to_double[s->source_pcm_res] */ ,

  1084.                             s->add_bias );

  1085.     }

  1086. 

  1087.     /* Down mixing */

  1088. 

  1089.     if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {

  1090.         dca_downmix(s->samples, s->amode, s->downmix_coef);

  1091.     }

  1092. 

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

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

  1095.         int lfe_samples = 2 * s->lfe * s->subsubframes;

  1096. 

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

  1098.                               s->lfe_data + lfe_samples +

  1099.                               2 * s->lfe * subsubframe,

  1100.                               &s->samples[256 * dca_lfe_index[s->amode]],

  1101.                               (1.0/256.0)*s->scale_bias,  s->add_bias);

  1102.         /* Outputs 20bits pcm samples */

  1103.     }

  1104. 

  1105.     return 0;

  1106. }

  1107. 

  1108. 

  1109. static int dca_subframe_footer(DCAContext * s)

  1110. {

  1111.     int aux_data_count = 0, i;

  1112.     int lfe_samples;

  1113. 

  1114.     /*

  1115.      * Unpack optional information

  1116.      */

  1117. 

  1118.     if (s->timestamp)

  1119.         get_bits(&s->gb, 32);

  1120. 

  1121.     if (s->aux_data)

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

  1123. 

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

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

  1126. 

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

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

  1129. 

  1130.     lfe_samples = 2 * s->lfe * s->subsubframes;

  1131.     for (i = 0; i < lfe_samples; i++) {

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

  1133.     }

  1134. 

  1135.     return 0;

  1136. }

  1137. 

  1138. /**

  1139.  * Decode a dca frame block

  1140.  *

  1141.  * @param s     pointer to the DCAContext

  1142.  */

  1143. 

  1144. static int dca_decode_block(DCAContext * s)

  1145. {

  1146. 

  1147.     /* Sanity check */

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

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

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

  1151.         return -1;

  1152.     }

  1153. 

  1154.     if (!s->current_subsubframe) {

  1155. #ifdef TRACE

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

  1157. #endif

  1158.         /* Read subframe header */

  1159.         if (dca_subframe_header(s))

  1160.             return -1;

  1161.     }

  1162. 

  1163.     /* Read subsubframe */

  1164. #ifdef TRACE

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

  1166. #endif

  1167.     if (dca_subsubframe(s))

  1168.         return -1;

  1169. 

  1170.     /* Update state */

  1171.     s->current_subsubframe++;

  1172.     if (s->current_subsubframe >= s->subsubframes) {

  1173.         s->current_subsubframe = 0;

  1174.         s->current_subframe++;

  1175.     }

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

  1177. #ifdef TRACE

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

  1179. #endif

  1180.         /* Read subframe footer */

  1181.         if (dca_subframe_footer(s))

  1182.             return -1;

  1183.     }

  1184. 

  1185.     return 0;

  1186. }

  1187. 

  1188. /**

  1189.  * Convert bitstream to one representation based on sync marker

  1190.  */

  1191. static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,

  1192.                           int max_size)

  1193. {

  1194.     uint32_t mrk;

  1195.     int i, tmp;

  1196.     const uint16_t *ssrc = (const uint16_t *) src;

  1197.     uint16_t *sdst = (uint16_t *) dst;

  1198.     PutBitContext pb;

  1199. 

  1200.     if((unsigned)src_size > (unsigned)max_size) {

  1201. //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger then DCA_MAX_FRAME_SIZE!\n");

  1202. //        return -1;

  1203.         src_size = max_size;

  1204.     }

  1205. 

  1206.     mrk = AV_RB32(src);

  1207.     switch (mrk) {

  1208.     case DCA_MARKER_RAW_BE:

  1209.         memcpy(dst, src, src_size);

  1210.         return src_size;

  1211.     case DCA_MARKER_RAW_LE:

  1212.         for (i = 0; i < (src_size + 1) >> 1; i++)

  1213.             *sdst++ = bswap_16(*ssrc++);

  1214.         return src_size;

  1215.     case DCA_MARKER_14B_BE:

  1216.     case DCA_MARKER_14B_LE:

  1217.         init_put_bits(&pb, dst, max_size);

  1218.         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {

  1219.             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;

  1220.             put_bits(&pb, 14, tmp);

  1221.         }

  1222.         flush_put_bits(&pb);

  1223.         return (put_bits_count(&pb) + 7) >> 3;

  1224.     default:

  1225.         return -1;

  1226.     }

  1227. }

  1228. 

  1229. /**

  1230.  * Main frame decoding function

  1231.  * FIXME add arguments

  1232.  */

  1233. static int dca_decode_frame(AVCodecContext * avctx,

  1234.                             void *data, int *data_size,

  1235.                             AVPacket *avpkt)

  1236. {

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

  1238.     int buf_size = avpkt->size;

  1239. 

  1240.     int i;

  1241.     int16_t *samples = data;

  1242.     DCAContext *s = avctx->priv_data;

  1243.     int channels;

  1244. 

  1245. 

  1246.     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);

  1247.     if (s->dca_buffer_size == -1) {

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

  1249.         return -1;

  1250.     }

  1251. 

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

  1253.     if (dca_parse_frame_header(s) < 0) {

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

  1255.         *data_size=0;

  1256.         return buf_size;

  1257.     }

  1258.     //set AVCodec values with parsed data

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

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

  1261. 

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

  1263. 

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

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

  1266. 

  1267.         if (s->lfe) {

  1268.             avctx->channel_layout |= CH_LOW_FREQUENCY;

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

  1270.         } else

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

  1272. 

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

  1274.             channels = 2;

  1275.             s->output = DCA_STEREO;

  1276.             avctx->channel_layout = CH_LAYOUT_STEREO;

  1277.         }

  1278.     } else {

  1279.         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);

  1280.         return -1;

  1281.     }

  1282. 

  1283. 

  1284.     /* There is nothing that prevents a dts frame to change channel configuration

  1285.        but FFmpeg doesn't support that so only set the channels if it is previously

  1286.        unset. Ideally during the first probe for channels the crc should be checked

  1287.        and only set avctx->channels when the crc is ok. Right now the decoder could

  1288.        set the channels based on a broken first frame.*/

  1289.     if (!avctx->channels)

  1290.         avctx->channels = channels;

  1291. 

  1292.     if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)

  1293.         return -1;

  1294.     *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;

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

  1296.         dca_decode_block(s);

  1297.         s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);

  1298.         samples += 256 * channels;

  1299.     }

  1300. 

  1301.     return buf_size;

  1302. }

  1303. 

  1304. 

  1305. 

  1306. /**

  1307.  * DCA initialization

  1308.  *

  1309.  * @param avctx     pointer to the AVCodecContext

  1310.  */

  1311. 

  1312. static av_cold int dca_decode_init(AVCodecContext * avctx)

  1313. {

  1314.     DCAContext *s = avctx->priv_data;

  1315.     int i;

  1316. 

  1317.     s->avctx = avctx;

  1318.     dca_init_vlcs();

  1319. 

  1320.     dsputil_init(&s->dsp, avctx);

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

  1322. 

  1323.     for(i = 0; i < 6; i++)

  1324.         s->samples_chanptr[i] = s->samples + i * 256;

  1325.     avctx->sample_fmt = SAMPLE_FMT_S16;

  1326. 

  1327.     if(s->dsp.float_to_int16 == ff_float_to_int16_c) {

  1328.         s->add_bias = 385.0f;

  1329.         s->scale_bias = 1.0 / 32768.0;

  1330.     } else {

  1331.         s->add_bias = 0.0f;

  1332.         s->scale_bias = 1.0;

  1333. 

  1334.         /* allow downmixing to stereo */

  1335.         if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&

  1336.                 avctx->request_channels == 2) {

  1337.             avctx->channels = avctx->request_channels;

  1338.         }

  1339.     }

  1340. 

  1341. 

  1342.     return 0;

  1343. }

  1344. 

  1345. static av_cold int dca_decode_end(AVCodecContext * avctx)

  1346. {

  1347.     DCAContext *s = avctx->priv_data;

  1348.     ff_mdct_end(&s->imdct);

  1349.     return 0;

  1350. }

  1351. 

  1352. AVCodec dca_decoder = {

  1353.     .name = "dca",

  1354.     .type = CODEC_TYPE_AUDIO,

  1355.     .id = CODEC_ID_DTS,

  1356.     .priv_data_size = sizeof(DCAContext),

  1357.     .init = dca_decode_init,

  1358.     .decode = dca_decode_frame,

  1359.     .close = dca_decode_end,

  1360.     .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),

  1361. };