libavcodec/dca.c
Go to the documentation of this file.
00001 /*
00002  * DCA compatible decoder
00003  * Copyright (C) 2004 Gildas Bazin
00004  * Copyright (C) 2004 Benjamin Zores
00005  * Copyright (C) 2006 Benjamin Larsson
00006  * Copyright (C) 2007 Konstantin Shishkov
00007  *
00008  * This file is part of Libav.
00009  *
00010  * Libav is free software; you can redistribute it and/or
00011  * modify it under the terms of the GNU Lesser General Public
00012  * License as published by the Free Software Foundation; either
00013  * version 2.1 of the License, or (at your option) any later version.
00014  *
00015  * Libav is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018  * Lesser General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU Lesser General Public
00021  * License along with Libav; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00023  */
00024 
00025 #include <math.h>
00026 #include <stddef.h>
00027 #include <stdio.h>
00028 
00029 #include "libavutil/common.h"
00030 #include "libavutil/intmath.h"
00031 #include "libavutil/intreadwrite.h"
00032 #include "libavutil/mathematics.h"
00033 #include "libavutil/audioconvert.h"
00034 #include "avcodec.h"
00035 #include "internal.h"
00036 #include "dsputil.h"
00037 #include "fft.h"
00038 #include "get_bits.h"
00039 #include "put_bits.h"
00040 #include "dcadata.h"
00041 #include "dcahuff.h"
00042 #include "dca.h"
00043 #include "synth_filter.h"
00044 #include "dcadsp.h"
00045 #include "fmtconvert.h"
00046 
00047 #if ARCH_ARM
00048 #   include "arm/dca.h"
00049 #endif
00050 
00051 //#define TRACE
00052 
00053 #define DCA_PRIM_CHANNELS_MAX  (7)
00054 #define DCA_SUBBANDS          (32)
00055 #define DCA_ABITS_MAX         (32)      /* Should be 28 */
00056 #define DCA_SUBSUBFRAMES_MAX   (4)
00057 #define DCA_SUBFRAMES_MAX     (16)
00058 #define DCA_BLOCKS_MAX        (16)
00059 #define DCA_LFE_MAX            (3)
00060 
00061 enum DCAMode {
00062     DCA_MONO = 0,
00063     DCA_CHANNEL,
00064     DCA_STEREO,
00065     DCA_STEREO_SUMDIFF,
00066     DCA_STEREO_TOTAL,
00067     DCA_3F,
00068     DCA_2F1R,
00069     DCA_3F1R,
00070     DCA_2F2R,
00071     DCA_3F2R,
00072     DCA_4F2R
00073 };
00074 
00075 /* these are unconfirmed but should be mostly correct */
00076 enum DCAExSSSpeakerMask {
00077     DCA_EXSS_FRONT_CENTER          = 0x0001,
00078     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
00079     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
00080     DCA_EXSS_LFE                   = 0x0008,
00081     DCA_EXSS_REAR_CENTER           = 0x0010,
00082     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
00083     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
00084     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
00085     DCA_EXSS_OVERHEAD              = 0x0100,
00086     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
00087     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
00088     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
00089     DCA_EXSS_LFE2                  = 0x1000,
00090     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
00091     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
00092     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
00093 };
00094 
00095 enum DCAExtensionMask {
00096     DCA_EXT_CORE       = 0x001, 
00097     DCA_EXT_XXCH       = 0x002, 
00098     DCA_EXT_X96        = 0x004, 
00099     DCA_EXT_XCH        = 0x008, 
00100     DCA_EXT_EXSS_CORE  = 0x010, 
00101     DCA_EXT_EXSS_XBR   = 0x020, 
00102     DCA_EXT_EXSS_XXCH  = 0x040, 
00103     DCA_EXT_EXSS_X96   = 0x080, 
00104     DCA_EXT_EXSS_LBR   = 0x100, 
00105     DCA_EXT_EXSS_XLL   = 0x200, 
00106 };
00107 
00108 /* -1 are reserved or unknown */
00109 static const int dca_ext_audio_descr_mask[] = {
00110     DCA_EXT_XCH,
00111     -1,
00112     DCA_EXT_X96,
00113     DCA_EXT_XCH | DCA_EXT_X96,
00114     -1,
00115     -1,
00116     DCA_EXT_XXCH,
00117     -1,
00118 };
00119 
00120 /* extensions that reside in core substream */
00121 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
00122 
00123 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
00124  * Some compromises have been made for special configurations. Most configurations
00125  * are never used so complete accuracy is not needed.
00126  *
00127  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
00128  * S  -> side, when both rear and back are configured move one of them to the side channel
00129  * OV -> center back
00130  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
00131  */
00132 static const uint64_t dca_core_channel_layout[] = {
00133     AV_CH_FRONT_CENTER,                                                     
00134     AV_CH_LAYOUT_STEREO,                                                    
00135     AV_CH_LAYOUT_STEREO,                                                    
00136     AV_CH_LAYOUT_STEREO,                                                    
00137     AV_CH_LAYOUT_STEREO,                                                    
00138     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               
00139     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                
00140     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           
00141     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               
00142 
00143     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
00144     AV_CH_SIDE_RIGHT,                                                       
00145 
00146     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
00147     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               
00148 
00149     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
00150     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                
00151 
00152     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
00153     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
00154     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     
00155 
00156     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
00157     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
00158     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     
00159 
00160     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
00161     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
00162     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     
00163 
00164     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
00165     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
00166     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 
00167 };
00168 
00169 static const int8_t dca_lfe_index[] = {
00170     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
00171 };
00172 
00173 static const int8_t dca_channel_reorder_lfe[][9] = {
00174     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
00175     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00176     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00177     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00178     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00179     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
00180     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00181     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
00182     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
00183     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
00184     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
00185     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
00186     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
00187     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
00188     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
00189     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
00190 };
00191 
00192 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
00193     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
00194     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00195     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00196     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00197     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00198     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
00199     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
00200     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
00201     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
00202     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
00203     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
00204     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
00205     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
00206     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
00207     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
00208     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
00209 };
00210 
00211 static const int8_t dca_channel_reorder_nolfe[][9] = {
00212     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
00213     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00214     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00215     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00216     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00217     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
00218     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00219     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
00220     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
00221     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
00222     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
00223     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
00224     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
00225     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
00226     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
00227     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
00228 };
00229 
00230 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
00231     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00232     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00233     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00234     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00235     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00236     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
00237     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
00238     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
00239     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
00240     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
00241     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
00242     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
00243     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
00244     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
00245     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
00246     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
00247 };
00248 
00249 #define DCA_DOLBY                  101           /* FIXME */
00250 
00251 #define DCA_CHANNEL_BITS             6
00252 #define DCA_CHANNEL_MASK          0x3F
00253 
00254 #define DCA_LFE                   0x80
00255 
00256 #define HEADER_SIZE                 14
00257 
00258 #define DCA_MAX_FRAME_SIZE       16384
00259 #define DCA_MAX_EXSS_HEADER_SIZE  4096
00260 
00261 #define DCA_BUFFER_PADDING_SIZE   1024
00262 
00264 typedef struct {
00265     int offset;                 
00266     int maxbits[8];             
00267     int wrap;                   
00268     VLC vlc[8];                 
00269 } BitAlloc;
00270 
00271 static BitAlloc dca_bitalloc_index;    
00272 static BitAlloc dca_tmode;             
00273 static BitAlloc dca_scalefactor;       
00274 static BitAlloc dca_smpl_bitalloc[11]; 
00275 
00276 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
00277                                          int idx)
00278 {
00279     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
00280            ba->offset;
00281 }
00282 
00283 typedef struct {
00284     AVCodecContext *avctx;
00285     AVFrame frame;
00286     /* Frame header */
00287     int frame_type;             
00288     int samples_deficit;        
00289     int crc_present;            
00290     int sample_blocks;          
00291     int frame_size;             
00292     int amode;                  
00293     int sample_rate;            
00294     int bit_rate;               
00295     int bit_rate_index;         
00296 
00297     int downmix;                
00298     int dynrange;               
00299     int timestamp;              
00300     int aux_data;               
00301     int hdcd;                   
00302     int ext_descr;              
00303     int ext_coding;             
00304     int aspf;                   
00305     int lfe;                    
00306     int predictor_history;      
00307     int header_crc;             
00308     int multirate_inter;        
00309     int version;                
00310     int copy_history;           
00311     int source_pcm_res;         
00312     int front_sum;              
00313     int surround_sum;           
00314     int dialog_norm;            
00315 
00316     /* Primary audio coding header */
00317     int subframes;              
00318     int is_channels_set;        
00319     int total_channels;         
00320     int prim_channels;          
00321     int subband_activity[DCA_PRIM_CHANNELS_MAX];    
00322     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    
00323     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     
00324     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   
00325     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; 
00326     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    
00327     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; 
00328     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   
00329 
00330     /* Primary audio coding side information */
00331     int subsubframes[DCA_SUBFRAMES_MAX];                         
00332     int partial_samples[DCA_SUBFRAMES_MAX];                      
00333     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    
00334     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      
00335     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           
00336     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    
00337     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    
00338     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       
00339     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; 
00340     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  
00341     int dynrange_coef;                                           
00342 
00343     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       
00344 
00345     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      
00346     int lfe_scale_factor;
00347 
00348     /* Subband samples history (for ADPCM) */
00349     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
00350     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
00351     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
00352     int hist_index[DCA_PRIM_CHANNELS_MAX];
00353     DECLARE_ALIGNED(32, float, raXin)[32];
00354 
00355     int output;                 
00356     float scale_bias;           
00357 
00358     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
00359     DECLARE_ALIGNED(32, float, samples)[(DCA_PRIM_CHANNELS_MAX + 1) * 256];
00360     const float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
00361 
00362     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
00363     int dca_buffer_size;        
00364 
00365     const int8_t *channel_order_tab;  
00366     GetBitContext gb;
00367     /* Current position in DCA frame */
00368     int current_subframe;
00369     int current_subsubframe;
00370 
00371     int core_ext_mask;          
00372 
00373     /* XCh extension information */
00374     int xch_present;            
00375     int xch_base_channel;       
00376 
00377     /* ExSS header parser */
00378     int static_fields;          
00379     int mix_metadata;           
00380     int num_mix_configs;        
00381     int mix_config_num_ch[4];   
00382 
00383     int profile;
00384 
00385     int debug_flag;             
00386     DSPContext dsp;
00387     FFTContext imdct;
00388     SynthFilterContext synth;
00389     DCADSPContext dcadsp;
00390     FmtConvertContext fmt_conv;
00391 } DCAContext;
00392 
00393 static const uint16_t dca_vlc_offs[] = {
00394         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
00395      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
00396      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
00397      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
00398     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
00399     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
00400 };
00401 
00402 static av_cold void dca_init_vlcs(void)
00403 {
00404     static int vlcs_initialized = 0;
00405     int i, j, c = 14;
00406     static VLC_TYPE dca_table[23622][2];
00407 
00408     if (vlcs_initialized)
00409         return;
00410 
00411     dca_bitalloc_index.offset = 1;
00412     dca_bitalloc_index.wrap = 2;
00413     for (i = 0; i < 5; i++) {
00414         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
00415         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
00416         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
00417                  bitalloc_12_bits[i], 1, 1,
00418                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00419     }
00420     dca_scalefactor.offset = -64;
00421     dca_scalefactor.wrap = 2;
00422     for (i = 0; i < 5; i++) {
00423         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
00424         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
00425         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
00426                  scales_bits[i], 1, 1,
00427                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00428     }
00429     dca_tmode.offset = 0;
00430     dca_tmode.wrap = 1;
00431     for (i = 0; i < 4; i++) {
00432         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
00433         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
00434         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
00435                  tmode_bits[i], 1, 1,
00436                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00437     }
00438 
00439     for (i = 0; i < 10; i++)
00440         for (j = 0; j < 7; j++) {
00441             if (!bitalloc_codes[i][j])
00442                 break;
00443             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
00444             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
00445             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
00446             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
00447 
00448             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
00449                      bitalloc_sizes[i],
00450                      bitalloc_bits[i][j], 1, 1,
00451                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
00452             c++;
00453         }
00454     vlcs_initialized = 1;
00455 }
00456 
00457 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
00458 {
00459     while (len--)
00460         *dst++ = get_bits(gb, bits);
00461 }
00462 
00463 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel)
00464 {
00465     int i, j;
00466     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
00467     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
00468     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
00469 
00470     s->total_channels = get_bits(&s->gb, 3) + 1 + base_channel;
00471     s->prim_channels  = s->total_channels;
00472 
00473     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
00474         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
00475 
00476 
00477     for (i = base_channel; i < s->prim_channels; i++) {
00478         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
00479         if (s->subband_activity[i] > DCA_SUBBANDS)
00480             s->subband_activity[i] = DCA_SUBBANDS;
00481     }
00482     for (i = base_channel; i < s->prim_channels; i++) {
00483         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
00484         if (s->vq_start_subband[i] > DCA_SUBBANDS)
00485             s->vq_start_subband[i] = DCA_SUBBANDS;
00486     }
00487     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
00488     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
00489     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
00490     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
00491 
00492     /* Get codebooks quantization indexes */
00493     if (!base_channel)
00494         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
00495     for (j = 1; j < 11; j++)
00496         for (i = base_channel; i < s->prim_channels; i++)
00497             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
00498 
00499     /* Get scale factor adjustment */
00500     for (j = 0; j < 11; j++)
00501         for (i = base_channel; i < s->prim_channels; i++)
00502             s->scalefactor_adj[i][j] = 1;
00503 
00504     for (j = 1; j < 11; j++)
00505         for (i = base_channel; i < s->prim_channels; i++)
00506             if (s->quant_index_huffman[i][j] < thr[j])
00507                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
00508 
00509     if (s->crc_present) {
00510         /* Audio header CRC check */
00511         get_bits(&s->gb, 16);
00512     }
00513 
00514     s->current_subframe    = 0;
00515     s->current_subsubframe = 0;
00516 
00517 #ifdef TRACE
00518     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
00519     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
00520     for (i = base_channel; i < s->prim_channels; i++) {
00521         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
00522                s->subband_activity[i]);
00523         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
00524                s->vq_start_subband[i]);
00525         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
00526                s->joint_intensity[i]);
00527         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
00528                s->transient_huffman[i]);
00529         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
00530                s->scalefactor_huffman[i]);
00531         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
00532                s->bitalloc_huffman[i]);
00533         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
00534         for (j = 0; j < 11; j++)
00535             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
00536         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00537         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
00538         for (j = 0; j < 11; j++)
00539             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
00540         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00541     }
00542 #endif
00543 
00544     return 0;
00545 }
00546 
00547 static int dca_parse_frame_header(DCAContext *s)
00548 {
00549     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
00550 
00551     /* Sync code */
00552     skip_bits_long(&s->gb, 32);
00553 
00554     /* Frame header */
00555     s->frame_type        = get_bits(&s->gb, 1);
00556     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
00557     s->crc_present       = get_bits(&s->gb, 1);
00558     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
00559     s->frame_size        = get_bits(&s->gb, 14) + 1;
00560     if (s->frame_size < 95)
00561         return AVERROR_INVALIDDATA;
00562     s->amode             = get_bits(&s->gb, 6);
00563     s->sample_rate       = dca_sample_rates[get_bits(&s->gb, 4)];
00564     if (!s->sample_rate)
00565         return AVERROR_INVALIDDATA;
00566     s->bit_rate_index    = get_bits(&s->gb, 5);
00567     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
00568     if (!s->bit_rate)
00569         return AVERROR_INVALIDDATA;
00570 
00571     s->downmix           = get_bits(&s->gb, 1);
00572     s->dynrange          = get_bits(&s->gb, 1);
00573     s->timestamp         = get_bits(&s->gb, 1);
00574     s->aux_data          = get_bits(&s->gb, 1);
00575     s->hdcd              = get_bits(&s->gb, 1);
00576     s->ext_descr         = get_bits(&s->gb, 3);
00577     s->ext_coding        = get_bits(&s->gb, 1);
00578     s->aspf              = get_bits(&s->gb, 1);
00579     s->lfe               = get_bits(&s->gb, 2);
00580     s->predictor_history = get_bits(&s->gb, 1);
00581 
00582     if (s->lfe > 2) {
00583         av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE value: %d\n", s->lfe);
00584         return AVERROR_INVALIDDATA;
00585     }
00586 
00587     /* TODO: check CRC */
00588     if (s->crc_present)
00589         s->header_crc    = get_bits(&s->gb, 16);
00590 
00591     s->multirate_inter   = get_bits(&s->gb, 1);
00592     s->version           = get_bits(&s->gb, 4);
00593     s->copy_history      = get_bits(&s->gb, 2);
00594     s->source_pcm_res    = get_bits(&s->gb, 3);
00595     s->front_sum         = get_bits(&s->gb, 1);
00596     s->surround_sum      = get_bits(&s->gb, 1);
00597     s->dialog_norm       = get_bits(&s->gb, 4);
00598 
00599     /* FIXME: channels mixing levels */
00600     s->output = s->amode;
00601     if (s->lfe)
00602         s->output |= DCA_LFE;
00603 
00604 #ifdef TRACE
00605     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
00606     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
00607     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
00608     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
00609            s->sample_blocks, s->sample_blocks * 32);
00610     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
00611     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
00612            s->amode, dca_channels[s->amode]);
00613     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
00614            s->sample_rate);
00615     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
00616            s->bit_rate);
00617     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
00618     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
00619     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
00620     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
00621     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
00622     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
00623     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
00624     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
00625     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
00626     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
00627            s->predictor_history);
00628     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
00629     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
00630            s->multirate_inter);
00631     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
00632     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
00633     av_log(s->avctx, AV_LOG_DEBUG,
00634            "source pcm resolution: %i (%i bits/sample)\n",
00635            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
00636     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
00637     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
00638     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
00639     av_log(s->avctx, AV_LOG_DEBUG, "\n");
00640 #endif
00641 
00642     /* Primary audio coding header */
00643     s->subframes         = get_bits(&s->gb, 4) + 1;
00644 
00645     return dca_parse_audio_coding_header(s, 0);
00646 }
00647 
00648 
00649 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
00650 {
00651     if (level < 5) {
00652         /* huffman encoded */
00653         value += get_bitalloc(gb, &dca_scalefactor, level);
00654         value = av_clip(value, 0, (1 << log2range) - 1);
00655     } else if (level < 8) {
00656         if (level + 1 > log2range) {
00657             skip_bits(gb, level + 1 - log2range);
00658             value = get_bits(gb, log2range);
00659         } else {
00660             value = get_bits(gb, level + 1);
00661         }
00662     }
00663     return value;
00664 }
00665 
00666 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
00667 {
00668     /* Primary audio coding side information */
00669     int j, k;
00670 
00671     if (get_bits_left(&s->gb) < 0)
00672         return AVERROR_INVALIDDATA;
00673 
00674     if (!base_channel) {
00675         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
00676         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
00677     }
00678 
00679     for (j = base_channel; j < s->prim_channels; j++) {
00680         for (k = 0; k < s->subband_activity[j]; k++)
00681             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
00682     }
00683 
00684     /* Get prediction codebook */
00685     for (j = base_channel; j < s->prim_channels; j++) {
00686         for (k = 0; k < s->subband_activity[j]; k++) {
00687             if (s->prediction_mode[j][k] > 0) {
00688                 /* (Prediction coefficient VQ address) */
00689                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00690             }
00691         }
00692     }
00693 
00694     /* Bit allocation index */
00695     for (j = base_channel; j < s->prim_channels; j++) {
00696         for (k = 0; k < s->vq_start_subband[j]; k++) {
00697             if (s->bitalloc_huffman[j] == 6)
00698                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
00699             else if (s->bitalloc_huffman[j] == 5)
00700                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
00701             else if (s->bitalloc_huffman[j] == 7) {
00702                 av_log(s->avctx, AV_LOG_ERROR,
00703                        "Invalid bit allocation index\n");
00704                 return AVERROR_INVALIDDATA;
00705             } else {
00706                 s->bitalloc[j][k] =
00707                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
00708             }
00709 
00710             if (s->bitalloc[j][k] > 26) {
00711                 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
00712                 //        j, k, s->bitalloc[j][k]);
00713                 return AVERROR_INVALIDDATA;
00714             }
00715         }
00716     }
00717 
00718     /* Transition mode */
00719     for (j = base_channel; j < s->prim_channels; j++) {
00720         for (k = 0; k < s->subband_activity[j]; k++) {
00721             s->transition_mode[j][k] = 0;
00722             if (s->subsubframes[s->current_subframe] > 1 &&
00723                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
00724                 s->transition_mode[j][k] =
00725                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
00726             }
00727         }
00728     }
00729 
00730     if (get_bits_left(&s->gb) < 0)
00731         return AVERROR_INVALIDDATA;
00732 
00733     for (j = base_channel; j < s->prim_channels; j++) {
00734         const uint32_t *scale_table;
00735         int scale_sum, log_size;
00736 
00737         memset(s->scale_factor[j], 0,
00738                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
00739 
00740         if (s->scalefactor_huffman[j] == 6) {
00741             scale_table = scale_factor_quant7;
00742             log_size = 7;
00743         } else {
00744             scale_table = scale_factor_quant6;
00745             log_size = 6;
00746         }
00747 
00748         /* When huffman coded, only the difference is encoded */
00749         scale_sum = 0;
00750 
00751         for (k = 0; k < s->subband_activity[j]; k++) {
00752             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
00753                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00754                 s->scale_factor[j][k][0] = scale_table[scale_sum];
00755             }
00756 
00757             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
00758                 /* Get second scale factor */
00759                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00760                 s->scale_factor[j][k][1] = scale_table[scale_sum];
00761             }
00762         }
00763     }
00764 
00765     /* Joint subband scale factor codebook select */
00766     for (j = base_channel; j < s->prim_channels; j++) {
00767         /* Transmitted only if joint subband coding enabled */
00768         if (s->joint_intensity[j] > 0)
00769             s->joint_huff[j] = get_bits(&s->gb, 3);
00770     }
00771 
00772     if (get_bits_left(&s->gb) < 0)
00773         return AVERROR_INVALIDDATA;
00774 
00775     /* Scale factors for joint subband coding */
00776     for (j = base_channel; j < s->prim_channels; j++) {
00777         int source_channel;
00778 
00779         /* Transmitted only if joint subband coding enabled */
00780         if (s->joint_intensity[j] > 0) {
00781             int scale = 0;
00782             source_channel = s->joint_intensity[j] - 1;
00783 
00784             /* When huffman coded, only the difference is encoded
00785              * (is this valid as well for joint scales ???) */
00786 
00787             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
00788                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
00789                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
00790             }
00791 
00792             if (!(s->debug_flag & 0x02)) {
00793                 av_log(s->avctx, AV_LOG_DEBUG,
00794                        "Joint stereo coding not supported\n");
00795                 s->debug_flag |= 0x02;
00796             }
00797         }
00798     }
00799 
00800     /* Stereo downmix coefficients */
00801     if (!base_channel && s->prim_channels > 2) {
00802         if (s->downmix) {
00803             for (j = base_channel; j < s->prim_channels; j++) {
00804                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
00805                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
00806             }
00807         } else {
00808             int am = s->amode & DCA_CHANNEL_MASK;
00809             if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
00810                 av_log(s->avctx, AV_LOG_ERROR,
00811                        "Invalid channel mode %d\n", am);
00812                 return AVERROR_INVALIDDATA;
00813             }
00814 
00815             if (s->prim_channels > FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
00816                 av_log_ask_for_sample(s->avctx, "Downmixing %d channels",
00817                                       s->prim_channels);
00818                 return AVERROR_PATCHWELCOME;
00819             }
00820 
00821             for (j = base_channel; j < s->prim_channels; j++) {
00822                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
00823                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
00824             }
00825         }
00826     }
00827 
00828     /* Dynamic range coefficient */
00829     if (!base_channel && s->dynrange)
00830         s->dynrange_coef = get_bits(&s->gb, 8);
00831 
00832     /* Side information CRC check word */
00833     if (s->crc_present) {
00834         get_bits(&s->gb, 16);
00835     }
00836 
00837     /*
00838      * Primary audio data arrays
00839      */
00840 
00841     /* VQ encoded high frequency subbands */
00842     for (j = base_channel; j < s->prim_channels; j++)
00843         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00844             /* 1 vector -> 32 samples */
00845             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00846 
00847     /* Low frequency effect data */
00848     if (!base_channel && s->lfe) {
00849         /* LFE samples */
00850         int lfe_samples = 2 * s->lfe * (4 + block_index);
00851         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00852         float lfe_scale;
00853 
00854         for (j = lfe_samples; j < lfe_end_sample; j++) {
00855             /* Signed 8 bits int */
00856             s->lfe_data[j] = get_sbits(&s->gb, 8);
00857         }
00858 
00859         /* Scale factor index */
00860         skip_bits(&s->gb, 1);
00861         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
00862 
00863         /* Quantization step size * scale factor */
00864         lfe_scale = 0.035 * s->lfe_scale_factor;
00865 
00866         for (j = lfe_samples; j < lfe_end_sample; j++)
00867             s->lfe_data[j] *= lfe_scale;
00868     }
00869 
00870 #ifdef TRACE
00871     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
00872            s->subsubframes[s->current_subframe]);
00873     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
00874            s->partial_samples[s->current_subframe]);
00875 
00876     for (j = base_channel; j < s->prim_channels; j++) {
00877         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
00878         for (k = 0; k < s->subband_activity[j]; k++)
00879             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
00880         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00881     }
00882     for (j = base_channel; j < s->prim_channels; j++) {
00883         for (k = 0; k < s->subband_activity[j]; k++)
00884             av_log(s->avctx, AV_LOG_DEBUG,
00885                    "prediction coefs: %f, %f, %f, %f\n",
00886                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
00887                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
00888                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
00889                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
00890     }
00891     for (j = base_channel; j < s->prim_channels; j++) {
00892         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
00893         for (k = 0; k < s->vq_start_subband[j]; k++)
00894             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
00895         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00896     }
00897     for (j = base_channel; j < s->prim_channels; j++) {
00898         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
00899         for (k = 0; k < s->subband_activity[j]; k++)
00900             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
00901         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00902     }
00903     for (j = base_channel; j < s->prim_channels; j++) {
00904         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
00905         for (k = 0; k < s->subband_activity[j]; k++) {
00906             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
00907                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
00908             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
00909                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
00910         }
00911         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00912     }
00913     for (j = base_channel; j < s->prim_channels; j++) {
00914         if (s->joint_intensity[j] > 0) {
00915             int source_channel = s->joint_intensity[j] - 1;
00916             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
00917             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
00918                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
00919             av_log(s->avctx, AV_LOG_DEBUG, "\n");
00920         }
00921     }
00922     if (!base_channel && s->prim_channels > 2 && s->downmix) {
00923         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
00924         for (j = 0; j < s->prim_channels; j++) {
00925             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
00926                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
00927             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
00928                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
00929         }
00930         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00931     }
00932     for (j = base_channel; j < s->prim_channels; j++)
00933         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00934             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
00935     if (!base_channel && s->lfe) {
00936         int lfe_samples = 2 * s->lfe * (4 + block_index);
00937         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00938 
00939         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
00940         for (j = lfe_samples; j < lfe_end_sample; j++)
00941             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
00942         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00943     }
00944 #endif
00945 
00946     return 0;
00947 }
00948 
00949 static void qmf_32_subbands(DCAContext *s, int chans,
00950                             float samples_in[32][8], float *samples_out,
00951                             float scale)
00952 {
00953     const float *prCoeff;
00954     int i;
00955 
00956     int sb_act = s->subband_activity[chans];
00957     int subindex;
00958 
00959     scale *= sqrt(1 / 8.0);
00960 
00961     /* Select filter */
00962     if (!s->multirate_inter)    /* Non-perfect reconstruction */
00963         prCoeff = fir_32bands_nonperfect;
00964     else                        /* Perfect reconstruction */
00965         prCoeff = fir_32bands_perfect;
00966 
00967     for (i = sb_act; i < 32; i++)
00968         s->raXin[i] = 0.0;
00969 
00970     /* Reconstructed channel sample index */
00971     for (subindex = 0; subindex < 8; subindex++) {
00972         /* Load in one sample from each subband and clear inactive subbands */
00973         for (i = 0; i < sb_act; i++) {
00974             unsigned sign = (i - 1) & 2;
00975             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
00976             AV_WN32A(&s->raXin[i], v);
00977         }
00978 
00979         s->synth.synth_filter_float(&s->imdct,
00980                                     s->subband_fir_hist[chans],
00981                                     &s->hist_index[chans],
00982                                     s->subband_fir_noidea[chans], prCoeff,
00983                                     samples_out, s->raXin, scale);
00984         samples_out += 32;
00985     }
00986 }
00987 
00988 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
00989                                   int num_deci_sample, float *samples_in,
00990                                   float *samples_out, float scale)
00991 {
00992     /* samples_in: An array holding decimated samples.
00993      *   Samples in current subframe starts from samples_in[0],
00994      *   while samples_in[-1], samples_in[-2], ..., stores samples
00995      *   from last subframe as history.
00996      *
00997      * samples_out: An array holding interpolated samples
00998      */
00999 
01000     int decifactor;
01001     const float *prCoeff;
01002     int deciindex;
01003 
01004     /* Select decimation filter */
01005     if (decimation_select == 1) {
01006         decifactor = 64;
01007         prCoeff = lfe_fir_128;
01008     } else {
01009         decifactor = 32;
01010         prCoeff = lfe_fir_64;
01011     }
01012     /* Interpolation */
01013     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
01014         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
01015         samples_in++;
01016         samples_out += 2 * decifactor;
01017     }
01018 }
01019 
01020 /* downmixing routines */
01021 #define MIX_REAR1(samples, si1, rs, coef)           \
01022     samples[i]     += samples[si1] * coef[rs][0];   \
01023     samples[i+256] += samples[si1] * coef[rs][1];
01024 
01025 #define MIX_REAR2(samples, si1, si2, rs, coef)                                     \
01026     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
01027     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
01028 
01029 #define MIX_FRONT3(samples, coef)                                      \
01030     t = samples[i + c];                                                \
01031     u = samples[i + l];                                                \
01032     v = samples[i + r];                                                \
01033     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
01034     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
01035 
01036 #define DOWNMIX_TO_STEREO(op1, op2)             \
01037     for (i = 0; i < 256; i++) {                 \
01038         op1                                     \
01039         op2                                     \
01040     }
01041 
01042 static void dca_downmix(float *samples, int srcfmt,
01043                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
01044                         const int8_t *channel_mapping)
01045 {
01046     int c, l, r, sl, sr, s;
01047     int i;
01048     float t, u, v;
01049     float coef[DCA_PRIM_CHANNELS_MAX][2];
01050 
01051     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
01052         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
01053         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
01054     }
01055 
01056     switch (srcfmt) {
01057     case DCA_MONO:
01058     case DCA_CHANNEL:
01059     case DCA_STEREO_TOTAL:
01060     case DCA_STEREO_SUMDIFF:
01061     case DCA_4F2R:
01062         av_log(NULL, 0, "Not implemented!\n");
01063         break;
01064     case DCA_STEREO:
01065         break;
01066     case DCA_3F:
01067         c = channel_mapping[0] * 256;
01068         l = channel_mapping[1] * 256;
01069         r = channel_mapping[2] * 256;
01070         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
01071         break;
01072     case DCA_2F1R:
01073         s = channel_mapping[2] * 256;
01074         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
01075         break;
01076     case DCA_3F1R:
01077         c = channel_mapping[0] * 256;
01078         l = channel_mapping[1] * 256;
01079         r = channel_mapping[2] * 256;
01080         s = channel_mapping[3] * 256;
01081         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01082                           MIX_REAR1(samples, i + s, 3, coef));
01083         break;
01084     case DCA_2F2R:
01085         sl = channel_mapping[2] * 256;
01086         sr = channel_mapping[3] * 256;
01087         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
01088         break;
01089     case DCA_3F2R:
01090         c  = channel_mapping[0] * 256;
01091         l  = channel_mapping[1] * 256;
01092         r  = channel_mapping[2] * 256;
01093         sl = channel_mapping[3] * 256;
01094         sr = channel_mapping[4] * 256;
01095         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01096                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
01097         break;
01098     }
01099 }
01100 
01101 
01102 #ifndef decode_blockcodes
01103 /* Very compact version of the block code decoder that does not use table
01104  * look-up but is slightly slower */
01105 static int decode_blockcode(int code, int levels, int *values)
01106 {
01107     int i;
01108     int offset = (levels - 1) >> 1;
01109 
01110     for (i = 0; i < 4; i++) {
01111         int div = FASTDIV(code, levels);
01112         values[i] = code - offset - div * levels;
01113         code = div;
01114     }
01115 
01116     return code;
01117 }
01118 
01119 static int decode_blockcodes(int code1, int code2, int levels, int *values)
01120 {
01121     return decode_blockcode(code1, levels, values) |
01122            decode_blockcode(code2, levels, values + 4);
01123 }
01124 #endif
01125 
01126 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
01127 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
01128 
01129 #ifndef int8x8_fmul_int32
01130 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
01131 {
01132     float fscale = scale / 16.0;
01133     int i;
01134     for (i = 0; i < 8; i++)
01135         dst[i] = src[i] * fscale;
01136 }
01137 #endif
01138 
01139 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
01140 {
01141     int k, l;
01142     int subsubframe = s->current_subsubframe;
01143 
01144     const float *quant_step_table;
01145 
01146     /* FIXME */
01147     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01148     LOCAL_ALIGNED_16(int, block, [8]);
01149 
01150     /*
01151      * Audio data
01152      */
01153 
01154     /* Select quantization step size table */
01155     if (s->bit_rate_index == 0x1f)
01156         quant_step_table = lossless_quant_d;
01157     else
01158         quant_step_table = lossy_quant_d;
01159 
01160     for (k = base_channel; k < s->prim_channels; k++) {
01161         if (get_bits_left(&s->gb) < 0)
01162             return AVERROR_INVALIDDATA;
01163 
01164         for (l = 0; l < s->vq_start_subband[k]; l++) {
01165             int m;
01166 
01167             /* Select the mid-tread linear quantizer */
01168             int abits = s->bitalloc[k][l];
01169 
01170             float quant_step_size = quant_step_table[abits];
01171 
01172             /*
01173              * Determine quantization index code book and its type
01174              */
01175 
01176             /* Select quantization index code book */
01177             int sel = s->quant_index_huffman[k][abits];
01178 
01179             /*
01180              * Extract bits from the bit stream
01181              */
01182             if (!abits) {
01183                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
01184             } else {
01185                 /* Deal with transients */
01186                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
01187                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
01188                                s->scalefactor_adj[k][sel];
01189 
01190                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
01191                     if (abits <= 7) {
01192                         /* Block code */
01193                         int block_code1, block_code2, size, levels, err;
01194 
01195                         size   = abits_sizes[abits - 1];
01196                         levels = abits_levels[abits - 1];
01197 
01198                         block_code1 = get_bits(&s->gb, size);
01199                         block_code2 = get_bits(&s->gb, size);
01200                         err = decode_blockcodes(block_code1, block_code2,
01201                                                 levels, block);
01202                         if (err) {
01203                             av_log(s->avctx, AV_LOG_ERROR,
01204                                    "ERROR: block code look-up failed\n");
01205                             return AVERROR_INVALIDDATA;
01206                         }
01207                     } else {
01208                         /* no coding */
01209                         for (m = 0; m < 8; m++)
01210                             block[m] = get_sbits(&s->gb, abits - 3);
01211                     }
01212                 } else {
01213                     /* Huffman coded */
01214                     for (m = 0; m < 8; m++)
01215                         block[m] = get_bitalloc(&s->gb,
01216                                                 &dca_smpl_bitalloc[abits], sel);
01217                 }
01218 
01219                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
01220                                                        block, rscale, 8);
01221             }
01222 
01223             /*
01224              * Inverse ADPCM if in prediction mode
01225              */
01226             if (s->prediction_mode[k][l]) {
01227                 int n;
01228                 for (m = 0; m < 8; m++) {
01229                     for (n = 1; n <= 4; n++)
01230                         if (m >= n)
01231                             subband_samples[k][l][m] +=
01232                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01233                                  subband_samples[k][l][m - n] / 8192);
01234                         else if (s->predictor_history)
01235                             subband_samples[k][l][m] +=
01236                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01237                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
01238                 }
01239             }
01240         }
01241 
01242         /*
01243          * Decode VQ encoded high frequencies
01244          */
01245         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01246             /* 1 vector -> 32 samples but we only need the 8 samples
01247              * for this subsubframe. */
01248             int hfvq = s->high_freq_vq[k][l];
01249 
01250             if (!s->debug_flag & 0x01) {
01251                 av_log(s->avctx, AV_LOG_DEBUG,
01252                        "Stream with high frequencies VQ coding\n");
01253                 s->debug_flag |= 0x01;
01254             }
01255 
01256             int8x8_fmul_int32(subband_samples[k][l],
01257                               &high_freq_vq[hfvq][subsubframe * 8],
01258                               s->scale_factor[k][l][0]);
01259         }
01260     }
01261 
01262     /* Check for DSYNC after subsubframe */
01263     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
01264         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
01265 #ifdef TRACE
01266             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
01267 #endif
01268         } else {
01269             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
01270             return AVERROR_INVALIDDATA;
01271         }
01272     }
01273 
01274     /* Backup predictor history for adpcm */
01275     for (k = base_channel; k < s->prim_channels; k++)
01276         for (l = 0; l < s->vq_start_subband[k]; l++)
01277             memcpy(s->subband_samples_hist[k][l],
01278                    &subband_samples[k][l][4],
01279                    4 * sizeof(subband_samples[0][0][0]));
01280 
01281     return 0;
01282 }
01283 
01284 static int dca_filter_channels(DCAContext *s, int block_index)
01285 {
01286     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01287     int k;
01288 
01289     /* 32 subbands QMF */
01290     for (k = 0; k < s->prim_channels; k++) {
01291 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
01292                                             0, 8388608.0, 8388608.0 };*/
01293         qmf_32_subbands(s, k, subband_samples[k],
01294                         &s->samples[256 * s->channel_order_tab[k]],
01295                         M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
01296     }
01297 
01298     /* Down mixing */
01299     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
01300         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
01301     }
01302 
01303     /* Generate LFE samples for this subsubframe FIXME!!! */
01304     if (s->output & DCA_LFE) {
01305         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
01306                               s->lfe_data + 2 * s->lfe * (block_index + 4),
01307                               &s->samples[256 * dca_lfe_index[s->amode]],
01308                               (1.0 / 256.0) * s->scale_bias);
01309         /* Outputs 20bits pcm samples */
01310     }
01311 
01312     return 0;
01313 }
01314 
01315 
01316 static int dca_subframe_footer(DCAContext *s, int base_channel)
01317 {
01318     int aux_data_count = 0, i;
01319 
01320     /*
01321      * Unpack optional information
01322      */
01323 
01324     /* presumably optional information only appears in the core? */
01325     if (!base_channel) {
01326         if (s->timestamp)
01327             skip_bits_long(&s->gb, 32);
01328 
01329         if (s->aux_data)
01330             aux_data_count = get_bits(&s->gb, 6);
01331 
01332         for (i = 0; i < aux_data_count; i++)
01333             get_bits(&s->gb, 8);
01334 
01335         if (s->crc_present && (s->downmix || s->dynrange))
01336             get_bits(&s->gb, 16);
01337     }
01338 
01339     return 0;
01340 }
01341 
01348 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
01349 {
01350     int ret;
01351 
01352     /* Sanity check */
01353     if (s->current_subframe >= s->subframes) {
01354         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
01355                s->current_subframe, s->subframes);
01356         return AVERROR_INVALIDDATA;
01357     }
01358 
01359     if (!s->current_subsubframe) {
01360 #ifdef TRACE
01361         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
01362 #endif
01363         /* Read subframe header */
01364         if ((ret = dca_subframe_header(s, base_channel, block_index)))
01365             return ret;
01366     }
01367 
01368     /* Read subsubframe */
01369 #ifdef TRACE
01370     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
01371 #endif
01372     if ((ret = dca_subsubframe(s, base_channel, block_index)))
01373         return ret;
01374 
01375     /* Update state */
01376     s->current_subsubframe++;
01377     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
01378         s->current_subsubframe = 0;
01379         s->current_subframe++;
01380     }
01381     if (s->current_subframe >= s->subframes) {
01382 #ifdef TRACE
01383         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
01384 #endif
01385         /* Read subframe footer */
01386         if ((ret = dca_subframe_footer(s, base_channel)))
01387             return ret;
01388     }
01389 
01390     return 0;
01391 }
01392 
01396 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
01397                                  int max_size)
01398 {
01399     uint32_t mrk;
01400     int i, tmp;
01401     const uint16_t *ssrc = (const uint16_t *) src;
01402     uint16_t *sdst = (uint16_t *) dst;
01403     PutBitContext pb;
01404 
01405     if ((unsigned) src_size > (unsigned) max_size) {
01406 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
01407 //        return -1;
01408         src_size = max_size;
01409     }
01410 
01411     mrk = AV_RB32(src);
01412     switch (mrk) {
01413     case DCA_MARKER_RAW_BE:
01414         memcpy(dst, src, src_size);
01415         return src_size;
01416     case DCA_MARKER_RAW_LE:
01417         for (i = 0; i < (src_size + 1) >> 1; i++)
01418             *sdst++ = av_bswap16(*ssrc++);
01419         return src_size;
01420     case DCA_MARKER_14B_BE:
01421     case DCA_MARKER_14B_LE:
01422         init_put_bits(&pb, dst, max_size);
01423         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
01424             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
01425             put_bits(&pb, 14, tmp);
01426         }
01427         flush_put_bits(&pb);
01428         return (put_bits_count(&pb) + 7) >> 3;
01429     default:
01430         return AVERROR_INVALIDDATA;
01431     }
01432 }
01433 
01437 static int dca_exss_mask2count(int mask)
01438 {
01439     /* count bits that mean speaker pairs twice */
01440     return av_popcount(mask) +
01441            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
01442                                DCA_EXSS_FRONT_LEFT_RIGHT       |
01443                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
01444                                DCA_EXSS_WIDE_LEFT_RIGHT        |
01445                                DCA_EXSS_SIDE_LEFT_RIGHT        |
01446                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
01447                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
01448                                DCA_EXSS_REAR_LEFT_RIGHT        |
01449                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
01450 }
01451 
01455 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
01456 {
01457     int i;
01458 
01459     for (i = 0; i < channels; i++) {
01460         int mix_map_mask = get_bits(gb, out_ch);
01461         int num_coeffs = av_popcount(mix_map_mask);
01462         skip_bits_long(gb, num_coeffs * 6);
01463     }
01464 }
01465 
01469 static int dca_exss_parse_asset_header(DCAContext *s)
01470 {
01471     int header_pos = get_bits_count(&s->gb);
01472     int header_size;
01473     int channels;
01474     int embedded_stereo = 0;
01475     int embedded_6ch    = 0;
01476     int drc_code_present;
01477     int extensions_mask;
01478     int i, j;
01479 
01480     if (get_bits_left(&s->gb) < 16)
01481         return -1;
01482 
01483     /* We will parse just enough to get to the extensions bitmask with which
01484      * we can set the profile value. */
01485 
01486     header_size = get_bits(&s->gb, 9) + 1;
01487     skip_bits(&s->gb, 3); // asset index
01488 
01489     if (s->static_fields) {
01490         if (get_bits1(&s->gb))
01491             skip_bits(&s->gb, 4); // asset type descriptor
01492         if (get_bits1(&s->gb))
01493             skip_bits_long(&s->gb, 24); // language descriptor
01494 
01495         if (get_bits1(&s->gb)) {
01496             /* How can one fit 1024 bytes of text here if the maximum value
01497              * for the asset header size field above was 512 bytes? */
01498             int text_length = get_bits(&s->gb, 10) + 1;
01499             if (get_bits_left(&s->gb) < text_length * 8)
01500                 return -1;
01501             skip_bits_long(&s->gb, text_length * 8); // info text
01502         }
01503 
01504         skip_bits(&s->gb, 5); // bit resolution - 1
01505         skip_bits(&s->gb, 4); // max sample rate code
01506         channels = get_bits(&s->gb, 8) + 1;
01507 
01508         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
01509             int spkr_remap_sets;
01510             int spkr_mask_size = 16;
01511             int num_spkrs[7];
01512 
01513             if (channels > 2)
01514                 embedded_stereo = get_bits1(&s->gb);
01515             if (channels > 6)
01516                 embedded_6ch = get_bits1(&s->gb);
01517 
01518             if (get_bits1(&s->gb)) {
01519                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
01520                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
01521             }
01522 
01523             spkr_remap_sets = get_bits(&s->gb, 3);
01524 
01525             for (i = 0; i < spkr_remap_sets; i++) {
01526                 /* std layout mask for each remap set */
01527                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
01528             }
01529 
01530             for (i = 0; i < spkr_remap_sets; i++) {
01531                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
01532                 if (get_bits_left(&s->gb) < 0)
01533                     return -1;
01534 
01535                 for (j = 0; j < num_spkrs[i]; j++) {
01536                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
01537                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
01538                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
01539                 }
01540             }
01541 
01542         } else {
01543             skip_bits(&s->gb, 3); // representation type
01544         }
01545     }
01546 
01547     drc_code_present = get_bits1(&s->gb);
01548     if (drc_code_present)
01549         get_bits(&s->gb, 8); // drc code
01550 
01551     if (get_bits1(&s->gb))
01552         skip_bits(&s->gb, 5); // dialog normalization code
01553 
01554     if (drc_code_present && embedded_stereo)
01555         get_bits(&s->gb, 8); // drc stereo code
01556 
01557     if (s->mix_metadata && get_bits1(&s->gb)) {
01558         skip_bits(&s->gb, 1); // external mix
01559         skip_bits(&s->gb, 6); // post mix gain code
01560 
01561         if (get_bits(&s->gb, 2) != 3) // mixer drc code
01562             skip_bits(&s->gb, 3); // drc limit
01563         else
01564             skip_bits(&s->gb, 8); // custom drc code
01565 
01566         if (get_bits1(&s->gb)) // channel specific scaling
01567             for (i = 0; i < s->num_mix_configs; i++)
01568                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
01569         else
01570             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
01571 
01572         for (i = 0; i < s->num_mix_configs; i++) {
01573             if (get_bits_left(&s->gb) < 0)
01574                 return -1;
01575             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
01576             if (embedded_6ch)
01577                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
01578             if (embedded_stereo)
01579                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
01580         }
01581     }
01582 
01583     switch (get_bits(&s->gb, 2)) {
01584     case 0: extensions_mask = get_bits(&s->gb, 12); break;
01585     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
01586     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
01587     case 3: extensions_mask = 0; /* aux coding */   break;
01588     }
01589 
01590     /* not parsed further, we were only interested in the extensions mask */
01591 
01592     if (get_bits_left(&s->gb) < 0)
01593         return -1;
01594 
01595     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
01596         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
01597         return -1;
01598     }
01599     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
01600 
01601     if (extensions_mask & DCA_EXT_EXSS_XLL)
01602         s->profile = FF_PROFILE_DTS_HD_MA;
01603     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
01604                                 DCA_EXT_EXSS_XXCH))
01605         s->profile = FF_PROFILE_DTS_HD_HRA;
01606 
01607     if (!(extensions_mask & DCA_EXT_CORE))
01608         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
01609     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
01610         av_log(s->avctx, AV_LOG_WARNING,
01611                "DTS extensions detection mismatch (%d, %d)\n",
01612                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
01613 
01614     return 0;
01615 }
01616 
01620 static void dca_exss_parse_header(DCAContext *s)
01621 {
01622     int ss_index;
01623     int blownup;
01624     int num_audiop = 1;
01625     int num_assets = 1;
01626     int active_ss_mask[8];
01627     int i, j;
01628 
01629     if (get_bits_left(&s->gb) < 52)
01630         return;
01631 
01632     skip_bits(&s->gb, 8); // user data
01633     ss_index = get_bits(&s->gb, 2);
01634 
01635     blownup = get_bits1(&s->gb);
01636     skip_bits(&s->gb,  8 + 4 * blownup); // header_size
01637     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
01638 
01639     s->static_fields = get_bits1(&s->gb);
01640     if (s->static_fields) {
01641         skip_bits(&s->gb, 2); // reference clock code
01642         skip_bits(&s->gb, 3); // frame duration code
01643 
01644         if (get_bits1(&s->gb))
01645             skip_bits_long(&s->gb, 36); // timestamp
01646 
01647         /* a single stream can contain multiple audio assets that can be
01648          * combined to form multiple audio presentations */
01649 
01650         num_audiop = get_bits(&s->gb, 3) + 1;
01651         if (num_audiop > 1) {
01652             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
01653             /* ignore such streams for now */
01654             return;
01655         }
01656 
01657         num_assets = get_bits(&s->gb, 3) + 1;
01658         if (num_assets > 1) {
01659             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
01660             /* ignore such streams for now */
01661             return;
01662         }
01663 
01664         for (i = 0; i < num_audiop; i++)
01665             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
01666 
01667         for (i = 0; i < num_audiop; i++)
01668             for (j = 0; j <= ss_index; j++)
01669                 if (active_ss_mask[i] & (1 << j))
01670                     skip_bits(&s->gb, 8); // active asset mask
01671 
01672         s->mix_metadata = get_bits1(&s->gb);
01673         if (s->mix_metadata) {
01674             int mix_out_mask_size;
01675 
01676             skip_bits(&s->gb, 2); // adjustment level
01677             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
01678             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
01679 
01680             for (i = 0; i < s->num_mix_configs; i++) {
01681                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
01682                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
01683             }
01684         }
01685     }
01686 
01687     for (i = 0; i < num_assets; i++)
01688         skip_bits_long(&s->gb, 16 + 4 * blownup);  // asset size
01689 
01690     for (i = 0; i < num_assets; i++) {
01691         if (dca_exss_parse_asset_header(s))
01692             return;
01693     }
01694 
01695     /* not parsed further, we were only interested in the extensions mask
01696      * from the asset header */
01697 }
01698 
01703 static int dca_decode_frame(AVCodecContext *avctx, void *data,
01704                             int *got_frame_ptr, AVPacket *avpkt)
01705 {
01706     const uint8_t *buf = avpkt->data;
01707     int buf_size = avpkt->size;
01708 
01709     int lfe_samples;
01710     int num_core_channels = 0;
01711     int i, ret;
01712     float   *samples_flt;
01713     int16_t *samples_s16;
01714     DCAContext *s = avctx->priv_data;
01715     int channels;
01716     int core_ss_end;
01717 
01718 
01719     s->xch_present = 0;
01720 
01721     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
01722                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
01723     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
01724         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
01725         return AVERROR_INVALIDDATA;
01726     }
01727 
01728     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
01729     if ((ret = dca_parse_frame_header(s)) < 0) {
01730         //seems like the frame is corrupt, try with the next one
01731         return ret;
01732     }
01733     //set AVCodec values with parsed data
01734     avctx->sample_rate = s->sample_rate;
01735     avctx->bit_rate    = s->bit_rate;
01736     avctx->frame_size  = s->sample_blocks * 32;
01737 
01738     s->profile = FF_PROFILE_DTS;
01739 
01740     for (i = 0; i < (s->sample_blocks / 8); i++) {
01741         if ((ret = dca_decode_block(s, 0, i))) {
01742             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
01743             return ret;
01744         }
01745     }
01746 
01747     /* record number of core channels incase less than max channels are requested */
01748     num_core_channels = s->prim_channels;
01749 
01750     if (s->ext_coding)
01751         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
01752     else
01753         s->core_ext_mask = 0;
01754 
01755     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
01756 
01757     /* only scan for extensions if ext_descr was unknown or indicated a
01758      * supported XCh extension */
01759     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
01760 
01761         /* if ext_descr was unknown, clear s->core_ext_mask so that the
01762          * extensions scan can fill it up */
01763         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
01764 
01765         /* extensions start at 32-bit boundaries into bitstream */
01766         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01767 
01768         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
01769             uint32_t bits = get_bits_long(&s->gb, 32);
01770 
01771             switch (bits) {
01772             case 0x5a5a5a5a: {
01773                 int ext_amode, xch_fsize;
01774 
01775                 s->xch_base_channel = s->prim_channels;
01776 
01777                 /* validate sync word using XCHFSIZE field */
01778                 xch_fsize = show_bits(&s->gb, 10);
01779                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
01780                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
01781                     continue;
01782 
01783                 /* skip length-to-end-of-frame field for the moment */
01784                 skip_bits(&s->gb, 10);
01785 
01786                 s->core_ext_mask |= DCA_EXT_XCH;
01787 
01788                 /* extension amode(number of channels in extension) should be 1 */
01789                 /* AFAIK XCh is not used for more channels */
01790                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
01791                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
01792                            " supported!\n", ext_amode);
01793                     continue;
01794                 }
01795 
01796                 /* much like core primary audio coding header */
01797                 dca_parse_audio_coding_header(s, s->xch_base_channel);
01798 
01799                 for (i = 0; i < (s->sample_blocks / 8); i++)
01800                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
01801                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
01802                         continue;
01803                     }
01804 
01805                 s->xch_present = 1;
01806                 break;
01807             }
01808             case 0x47004a03:
01809                 /* XXCh: extended channels */
01810                 /* usually found either in core or HD part in DTS-HD HRA streams,
01811                  * but not in DTS-ES which contains XCh extensions instead */
01812                 s->core_ext_mask |= DCA_EXT_XXCH;
01813                 break;
01814 
01815             case 0x1d95f262: {
01816                 int fsize96 = show_bits(&s->gb, 12) + 1;
01817                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
01818                     continue;
01819 
01820                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
01821                        get_bits_count(&s->gb));
01822                 skip_bits(&s->gb, 12);
01823                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
01824                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
01825 
01826                 s->core_ext_mask |= DCA_EXT_X96;
01827                 break;
01828             }
01829             }
01830 
01831             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01832         }
01833     } else {
01834         /* no supported extensions, skip the rest of the core substream */
01835         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
01836     }
01837 
01838     if (s->core_ext_mask & DCA_EXT_X96)
01839         s->profile = FF_PROFILE_DTS_96_24;
01840     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
01841         s->profile = FF_PROFILE_DTS_ES;
01842 
01843     /* check for ExSS (HD part) */
01844     if (s->dca_buffer_size - s->frame_size > 32 &&
01845         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
01846         dca_exss_parse_header(s);
01847 
01848     avctx->profile = s->profile;
01849 
01850     channels = s->prim_channels + !!s->lfe;
01851 
01852     if (s->amode < 16) {
01853         avctx->channel_layout = dca_core_channel_layout[s->amode];
01854 
01855         if (s->xch_present && (!avctx->request_channels ||
01856                                avctx->request_channels > num_core_channels + !!s->lfe)) {
01857             avctx->channel_layout |= AV_CH_BACK_CENTER;
01858             if (s->lfe) {
01859                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01860                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
01861             } else {
01862                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
01863             }
01864         } else {
01865             channels = num_core_channels + !!s->lfe;
01866             s->xch_present = 0; /* disable further xch processing */
01867             if (s->lfe) {
01868                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01869                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
01870             } else
01871                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
01872         }
01873 
01874         if (channels > !!s->lfe &&
01875             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
01876             return AVERROR_INVALIDDATA;
01877 
01878         if (avctx->request_channels == 2 && s->prim_channels > 2) {
01879             channels = 2;
01880             s->output = DCA_STEREO;
01881             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
01882         }
01883     } else {
01884         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
01885         return AVERROR_INVALIDDATA;
01886     }
01887 
01888 
01889     /* There is nothing that prevents a dts frame to change channel configuration
01890        but Libav doesn't support that so only set the channels if it is previously
01891        unset. Ideally during the first probe for channels the crc should be checked
01892        and only set avctx->channels when the crc is ok. Right now the decoder could
01893        set the channels based on a broken first frame.*/
01894     if (s->is_channels_set == 0) {
01895         s->is_channels_set = 1;
01896         avctx->channels = channels;
01897     }
01898     if (avctx->channels != channels) {
01899         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
01900                "channels changing in stream. Skipping frame.\n");
01901         return AVERROR_PATCHWELCOME;
01902     }
01903 
01904     /* get output buffer */
01905     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
01906     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
01907         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01908         return ret;
01909     }
01910     samples_flt = (float *)   s->frame.data[0];
01911     samples_s16 = (int16_t *) s->frame.data[0];
01912 
01913     /* filter to get final output */
01914     for (i = 0; i < (s->sample_blocks / 8); i++) {
01915         dca_filter_channels(s, i);
01916 
01917         /* If this was marked as a DTS-ES stream we need to subtract back- */
01918         /* channel from SL & SR to remove matrixed back-channel signal */
01919         if ((s->source_pcm_res & 1) && s->xch_present) {
01920             float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel]     * 256;
01921             float *lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
01922             float *rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
01923             s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
01924             s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
01925         }
01926 
01927         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
01928             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
01929                                          channels);
01930             samples_flt += 256 * channels;
01931         } else {
01932             s->fmt_conv.float_to_int16_interleave(samples_s16,
01933                                                   s->samples_chanptr, 256,
01934                                                   channels);
01935             samples_s16 += 256 * channels;
01936         }
01937     }
01938 
01939     /* update lfe history */
01940     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
01941     for (i = 0; i < 2 * s->lfe * 4; i++)
01942         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
01943 
01944     *got_frame_ptr    = 1;
01945     *(AVFrame *) data = s->frame;
01946 
01947     return buf_size;
01948 }
01949 
01950 
01951 
01958 static av_cold int dca_decode_init(AVCodecContext *avctx)
01959 {
01960     DCAContext *s = avctx->priv_data;
01961     int i;
01962 
01963     s->avctx = avctx;
01964     dca_init_vlcs();
01965 
01966     dsputil_init(&s->dsp, avctx);
01967     ff_mdct_init(&s->imdct, 6, 1, 1.0);
01968     ff_synth_filter_init(&s->synth);
01969     ff_dcadsp_init(&s->dcadsp);
01970     ff_fmt_convert_init(&s->fmt_conv, avctx);
01971 
01972     for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
01973         s->samples_chanptr[i] = s->samples + i * 256;
01974 
01975     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
01976         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
01977         s->scale_bias     = 1.0 / 32768.0;
01978     } else {
01979         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01980         s->scale_bias     = 1.0;
01981     }
01982 
01983     /* allow downmixing to stereo */
01984     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
01985         avctx->request_channels == 2) {
01986         avctx->channels = avctx->request_channels;
01987     }
01988 
01989     avcodec_get_frame_defaults(&s->frame);
01990     avctx->coded_frame = &s->frame;
01991 
01992     return 0;
01993 }
01994 
01995 static av_cold int dca_decode_end(AVCodecContext *avctx)
01996 {
01997     DCAContext *s = avctx->priv_data;
01998     ff_mdct_end(&s->imdct);
01999     return 0;
02000 }
02001 
02002 static const AVProfile profiles[] = {
02003     { FF_PROFILE_DTS,        "DTS"        },
02004     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
02005     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
02006     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
02007     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
02008     { FF_PROFILE_UNKNOWN },
02009 };
02010 
02011 AVCodec ff_dca_decoder = {
02012     .name            = "dca",
02013     .type            = AVMEDIA_TYPE_AUDIO,
02014     .id              = CODEC_ID_DTS,
02015     .priv_data_size  = sizeof(DCAContext),
02016     .init            = dca_decode_init,
02017     .decode          = dca_decode_frame,
02018     .close           = dca_decode_end,
02019     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
02020     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
02021     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
02022                                                        AV_SAMPLE_FMT_S16,
02023                                                        AV_SAMPLE_FMT_NONE },
02024     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
02025 };