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