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     /* TODO: check CRC */
00582     if (s->crc_present)
00583         s->header_crc    = get_bits(&s->gb, 16);
00584 
00585     s->multirate_inter   = get_bits(&s->gb, 1);
00586     s->version           = get_bits(&s->gb, 4);
00587     s->copy_history      = get_bits(&s->gb, 2);
00588     s->source_pcm_res    = get_bits(&s->gb, 3);
00589     s->front_sum         = get_bits(&s->gb, 1);
00590     s->surround_sum      = get_bits(&s->gb, 1);
00591     s->dialog_norm       = get_bits(&s->gb, 4);
00592 
00593     /* FIXME: channels mixing levels */
00594     s->output = s->amode;
00595     if (s->lfe)
00596         s->output |= DCA_LFE;
00597 
00598 #ifdef TRACE
00599     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
00600     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
00601     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
00602     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
00603            s->sample_blocks, s->sample_blocks * 32);
00604     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
00605     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
00606            s->amode, dca_channels[s->amode]);
00607     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
00608            s->sample_rate);
00609     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
00610            s->bit_rate);
00611     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
00612     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
00613     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
00614     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
00615     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
00616     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
00617     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
00618     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
00619     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
00620     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
00621            s->predictor_history);
00622     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
00623     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
00624            s->multirate_inter);
00625     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
00626     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
00627     av_log(s->avctx, AV_LOG_DEBUG,
00628            "source pcm resolution: %i (%i bits/sample)\n",
00629            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
00630     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
00631     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
00632     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
00633     av_log(s->avctx, AV_LOG_DEBUG, "\n");
00634 #endif
00635 
00636     /* Primary audio coding header */
00637     s->subframes         = get_bits(&s->gb, 4) + 1;
00638 
00639     return dca_parse_audio_coding_header(s, 0);
00640 }
00641 
00642 
00643 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
00644 {
00645     if (level < 5) {
00646         /* huffman encoded */
00647         value += get_bitalloc(gb, &dca_scalefactor, level);
00648         value = av_clip(value, 0, (1 << log2range) - 1);
00649     } else if (level < 8) {
00650         if (level + 1 > log2range) {
00651             skip_bits(gb, level + 1 - log2range);
00652             value = get_bits(gb, log2range);
00653         } else {
00654             value = get_bits(gb, level + 1);
00655         }
00656     }
00657     return value;
00658 }
00659 
00660 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
00661 {
00662     /* Primary audio coding side information */
00663     int j, k;
00664 
00665     if (get_bits_left(&s->gb) < 0)
00666         return AVERROR_INVALIDDATA;
00667 
00668     if (!base_channel) {
00669         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
00670         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
00671     }
00672 
00673     for (j = base_channel; j < s->prim_channels; j++) {
00674         for (k = 0; k < s->subband_activity[j]; k++)
00675             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
00676     }
00677 
00678     /* Get prediction codebook */
00679     for (j = base_channel; j < s->prim_channels; j++) {
00680         for (k = 0; k < s->subband_activity[j]; k++) {
00681             if (s->prediction_mode[j][k] > 0) {
00682                 /* (Prediction coefficient VQ address) */
00683                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00684             }
00685         }
00686     }
00687 
00688     /* Bit allocation index */
00689     for (j = base_channel; j < s->prim_channels; j++) {
00690         for (k = 0; k < s->vq_start_subband[j]; k++) {
00691             if (s->bitalloc_huffman[j] == 6)
00692                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
00693             else if (s->bitalloc_huffman[j] == 5)
00694                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
00695             else if (s->bitalloc_huffman[j] == 7) {
00696                 av_log(s->avctx, AV_LOG_ERROR,
00697                        "Invalid bit allocation index\n");
00698                 return AVERROR_INVALIDDATA;
00699             } else {
00700                 s->bitalloc[j][k] =
00701                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
00702             }
00703 
00704             if (s->bitalloc[j][k] > 26) {
00705                 // av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index [%i][%i] too big (%i)\n",
00706                 //        j, k, s->bitalloc[j][k]);
00707                 return AVERROR_INVALIDDATA;
00708             }
00709         }
00710     }
00711 
00712     /* Transition mode */
00713     for (j = base_channel; j < s->prim_channels; j++) {
00714         for (k = 0; k < s->subband_activity[j]; k++) {
00715             s->transition_mode[j][k] = 0;
00716             if (s->subsubframes[s->current_subframe] > 1 &&
00717                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
00718                 s->transition_mode[j][k] =
00719                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
00720             }
00721         }
00722     }
00723 
00724     if (get_bits_left(&s->gb) < 0)
00725         return AVERROR_INVALIDDATA;
00726 
00727     for (j = base_channel; j < s->prim_channels; j++) {
00728         const uint32_t *scale_table;
00729         int scale_sum, log_size;
00730 
00731         memset(s->scale_factor[j], 0,
00732                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
00733 
00734         if (s->scalefactor_huffman[j] == 6) {
00735             scale_table = scale_factor_quant7;
00736             log_size = 7;
00737         } else {
00738             scale_table = scale_factor_quant6;
00739             log_size = 6;
00740         }
00741 
00742         /* When huffman coded, only the difference is encoded */
00743         scale_sum = 0;
00744 
00745         for (k = 0; k < s->subband_activity[j]; k++) {
00746             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
00747                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00748                 s->scale_factor[j][k][0] = scale_table[scale_sum];
00749             }
00750 
00751             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
00752                 /* Get second scale factor */
00753                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00754                 s->scale_factor[j][k][1] = scale_table[scale_sum];
00755             }
00756         }
00757     }
00758 
00759     /* Joint subband scale factor codebook select */
00760     for (j = base_channel; j < s->prim_channels; j++) {
00761         /* Transmitted only if joint subband coding enabled */
00762         if (s->joint_intensity[j] > 0)
00763             s->joint_huff[j] = get_bits(&s->gb, 3);
00764     }
00765 
00766     if (get_bits_left(&s->gb) < 0)
00767         return AVERROR_INVALIDDATA;
00768 
00769     /* Scale factors for joint subband coding */
00770     for (j = base_channel; j < s->prim_channels; j++) {
00771         int source_channel;
00772 
00773         /* Transmitted only if joint subband coding enabled */
00774         if (s->joint_intensity[j] > 0) {
00775             int scale = 0;
00776             source_channel = s->joint_intensity[j] - 1;
00777 
00778             /* When huffman coded, only the difference is encoded
00779              * (is this valid as well for joint scales ???) */
00780 
00781             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
00782                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
00783                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
00784             }
00785 
00786             if (!(s->debug_flag & 0x02)) {
00787                 av_log(s->avctx, AV_LOG_DEBUG,
00788                        "Joint stereo coding not supported\n");
00789                 s->debug_flag |= 0x02;
00790             }
00791         }
00792     }
00793 
00794     /* Stereo downmix coefficients */
00795     if (!base_channel && s->prim_channels > 2) {
00796         if (s->downmix) {
00797             for (j = base_channel; j < s->prim_channels; j++) {
00798                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
00799                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
00800             }
00801         } else {
00802             int am = s->amode & DCA_CHANNEL_MASK;
00803             if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
00804                 av_log(s->avctx, AV_LOG_ERROR,
00805                        "Invalid channel mode %d\n", am);
00806                 return AVERROR_INVALIDDATA;
00807             }
00808 
00809             if (s->prim_channels > FF_ARRAY_ELEMS(dca_default_coeffs[0])) {
00810                 av_log_ask_for_sample(s->avctx, "Downmixing %d channels",
00811                                       s->prim_channels);
00812                 return AVERROR_PATCHWELCOME;
00813             }
00814 
00815             for (j = base_channel; j < s->prim_channels; j++) {
00816                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
00817                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
00818             }
00819         }
00820     }
00821 
00822     /* Dynamic range coefficient */
00823     if (!base_channel && s->dynrange)
00824         s->dynrange_coef = get_bits(&s->gb, 8);
00825 
00826     /* Side information CRC check word */
00827     if (s->crc_present) {
00828         get_bits(&s->gb, 16);
00829     }
00830 
00831     /*
00832      * Primary audio data arrays
00833      */
00834 
00835     /* VQ encoded high frequency subbands */
00836     for (j = base_channel; j < s->prim_channels; j++)
00837         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00838             /* 1 vector -> 32 samples */
00839             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00840 
00841     /* Low frequency effect data */
00842     if (!base_channel && s->lfe) {
00843         /* LFE samples */
00844         int lfe_samples = 2 * s->lfe * (4 + block_index);
00845         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00846         float lfe_scale;
00847 
00848         for (j = lfe_samples; j < lfe_end_sample; j++) {
00849             /* Signed 8 bits int */
00850             s->lfe_data[j] = get_sbits(&s->gb, 8);
00851         }
00852 
00853         /* Scale factor index */
00854         skip_bits(&s->gb, 1);
00855         s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
00856 
00857         /* Quantization step size * scale factor */
00858         lfe_scale = 0.035 * s->lfe_scale_factor;
00859 
00860         for (j = lfe_samples; j < lfe_end_sample; j++)
00861             s->lfe_data[j] *= lfe_scale;
00862     }
00863 
00864 #ifdef TRACE
00865     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
00866            s->subsubframes[s->current_subframe]);
00867     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
00868            s->partial_samples[s->current_subframe]);
00869 
00870     for (j = base_channel; j < s->prim_channels; j++) {
00871         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
00872         for (k = 0; k < s->subband_activity[j]; k++)
00873             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
00874         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00875     }
00876     for (j = base_channel; j < s->prim_channels; j++) {
00877         for (k = 0; k < s->subband_activity[j]; k++)
00878             av_log(s->avctx, AV_LOG_DEBUG,
00879                    "prediction coefs: %f, %f, %f, %f\n",
00880                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
00881                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
00882                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
00883                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
00884     }
00885     for (j = base_channel; j < s->prim_channels; j++) {
00886         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
00887         for (k = 0; k < s->vq_start_subband[j]; k++)
00888             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
00889         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00890     }
00891     for (j = base_channel; j < s->prim_channels; j++) {
00892         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
00893         for (k = 0; k < s->subband_activity[j]; k++)
00894             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[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, "Scale factor:");
00899         for (k = 0; k < s->subband_activity[j]; k++) {
00900             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
00901                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
00902             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
00903                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
00904         }
00905         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00906     }
00907     for (j = base_channel; j < s->prim_channels; j++) {
00908         if (s->joint_intensity[j] > 0) {
00909             int source_channel = s->joint_intensity[j] - 1;
00910             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
00911             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
00912                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
00913             av_log(s->avctx, AV_LOG_DEBUG, "\n");
00914         }
00915     }
00916     if (!base_channel && s->prim_channels > 2 && s->downmix) {
00917         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
00918         for (j = 0; j < s->prim_channels; j++) {
00919             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
00920                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
00921             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
00922                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
00923         }
00924         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00925     }
00926     for (j = base_channel; j < s->prim_channels; j++)
00927         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00928             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
00929     if (!base_channel && s->lfe) {
00930         int lfe_samples = 2 * s->lfe * (4 + block_index);
00931         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00932 
00933         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
00934         for (j = lfe_samples; j < lfe_end_sample; j++)
00935             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
00936         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00937     }
00938 #endif
00939 
00940     return 0;
00941 }
00942 
00943 static void qmf_32_subbands(DCAContext *s, int chans,
00944                             float samples_in[32][8], float *samples_out,
00945                             float scale)
00946 {
00947     const float *prCoeff;
00948     int i;
00949 
00950     int sb_act = s->subband_activity[chans];
00951     int subindex;
00952 
00953     scale *= sqrt(1 / 8.0);
00954 
00955     /* Select filter */
00956     if (!s->multirate_inter)    /* Non-perfect reconstruction */
00957         prCoeff = fir_32bands_nonperfect;
00958     else                        /* Perfect reconstruction */
00959         prCoeff = fir_32bands_perfect;
00960 
00961     for (i = sb_act; i < 32; i++)
00962         s->raXin[i] = 0.0;
00963 
00964     /* Reconstructed channel sample index */
00965     for (subindex = 0; subindex < 8; subindex++) {
00966         /* Load in one sample from each subband and clear inactive subbands */
00967         for (i = 0; i < sb_act; i++) {
00968             unsigned sign = (i - 1) & 2;
00969             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
00970             AV_WN32A(&s->raXin[i], v);
00971         }
00972 
00973         s->synth.synth_filter_float(&s->imdct,
00974                                     s->subband_fir_hist[chans],
00975                                     &s->hist_index[chans],
00976                                     s->subband_fir_noidea[chans], prCoeff,
00977                                     samples_out, s->raXin, scale);
00978         samples_out += 32;
00979     }
00980 }
00981 
00982 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
00983                                   int num_deci_sample, float *samples_in,
00984                                   float *samples_out, float scale)
00985 {
00986     /* samples_in: An array holding decimated samples.
00987      *   Samples in current subframe starts from samples_in[0],
00988      *   while samples_in[-1], samples_in[-2], ..., stores samples
00989      *   from last subframe as history.
00990      *
00991      * samples_out: An array holding interpolated samples
00992      */
00993 
00994     int decifactor;
00995     const float *prCoeff;
00996     int deciindex;
00997 
00998     /* Select decimation filter */
00999     if (decimation_select == 1) {
01000         decifactor = 64;
01001         prCoeff = lfe_fir_128;
01002     } else {
01003         decifactor = 32;
01004         prCoeff = lfe_fir_64;
01005     }
01006     /* Interpolation */
01007     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
01008         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
01009         samples_in++;
01010         samples_out += 2 * decifactor;
01011     }
01012 }
01013 
01014 /* downmixing routines */
01015 #define MIX_REAR1(samples, si1, rs, coef)           \
01016     samples[i]     += samples[si1] * coef[rs][0];   \
01017     samples[i+256] += samples[si1] * coef[rs][1];
01018 
01019 #define MIX_REAR2(samples, si1, si2, rs, coef)                                     \
01020     samples[i]     += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
01021     samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
01022 
01023 #define MIX_FRONT3(samples, coef)                                      \
01024     t = samples[i + c];                                                \
01025     u = samples[i + l];                                                \
01026     v = samples[i + r];                                                \
01027     samples[i]     = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
01028     samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
01029 
01030 #define DOWNMIX_TO_STEREO(op1, op2)             \
01031     for (i = 0; i < 256; i++) {                 \
01032         op1                                     \
01033         op2                                     \
01034     }
01035 
01036 static void dca_downmix(float *samples, int srcfmt,
01037                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
01038                         const int8_t *channel_mapping)
01039 {
01040     int c, l, r, sl, sr, s;
01041     int i;
01042     float t, u, v;
01043     float coef[DCA_PRIM_CHANNELS_MAX][2];
01044 
01045     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
01046         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
01047         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
01048     }
01049 
01050     switch (srcfmt) {
01051     case DCA_MONO:
01052     case DCA_CHANNEL:
01053     case DCA_STEREO_TOTAL:
01054     case DCA_STEREO_SUMDIFF:
01055     case DCA_4F2R:
01056         av_log(NULL, 0, "Not implemented!\n");
01057         break;
01058     case DCA_STEREO:
01059         break;
01060     case DCA_3F:
01061         c = channel_mapping[0] * 256;
01062         l = channel_mapping[1] * 256;
01063         r = channel_mapping[2] * 256;
01064         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
01065         break;
01066     case DCA_2F1R:
01067         s = channel_mapping[2] * 256;
01068         DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
01069         break;
01070     case DCA_3F1R:
01071         c = channel_mapping[0] * 256;
01072         l = channel_mapping[1] * 256;
01073         r = channel_mapping[2] * 256;
01074         s = channel_mapping[3] * 256;
01075         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01076                           MIX_REAR1(samples, i + s, 3, coef));
01077         break;
01078     case DCA_2F2R:
01079         sl = channel_mapping[2] * 256;
01080         sr = channel_mapping[3] * 256;
01081         DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
01082         break;
01083     case DCA_3F2R:
01084         c  = channel_mapping[0] * 256;
01085         l  = channel_mapping[1] * 256;
01086         r  = channel_mapping[2] * 256;
01087         sl = channel_mapping[3] * 256;
01088         sr = channel_mapping[4] * 256;
01089         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01090                           MIX_REAR2(samples, i + sl, i + sr, 3, coef));
01091         break;
01092     }
01093 }
01094 
01095 
01096 #ifndef decode_blockcodes
01097 /* Very compact version of the block code decoder that does not use table
01098  * look-up but is slightly slower */
01099 static int decode_blockcode(int code, int levels, int *values)
01100 {
01101     int i;
01102     int offset = (levels - 1) >> 1;
01103 
01104     for (i = 0; i < 4; i++) {
01105         int div = FASTDIV(code, levels);
01106         values[i] = code - offset - div * levels;
01107         code = div;
01108     }
01109 
01110     return code;
01111 }
01112 
01113 static int decode_blockcodes(int code1, int code2, int levels, int *values)
01114 {
01115     return decode_blockcode(code1, levels, values) |
01116            decode_blockcode(code2, levels, values + 4);
01117 }
01118 #endif
01119 
01120 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
01121 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
01122 
01123 #ifndef int8x8_fmul_int32
01124 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
01125 {
01126     float fscale = scale / 16.0;
01127     int i;
01128     for (i = 0; i < 8; i++)
01129         dst[i] = src[i] * fscale;
01130 }
01131 #endif
01132 
01133 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
01134 {
01135     int k, l;
01136     int subsubframe = s->current_subsubframe;
01137 
01138     const float *quant_step_table;
01139 
01140     /* FIXME */
01141     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01142     LOCAL_ALIGNED_16(int, block, [8]);
01143 
01144     /*
01145      * Audio data
01146      */
01147 
01148     /* Select quantization step size table */
01149     if (s->bit_rate_index == 0x1f)
01150         quant_step_table = lossless_quant_d;
01151     else
01152         quant_step_table = lossy_quant_d;
01153 
01154     for (k = base_channel; k < s->prim_channels; k++) {
01155         if (get_bits_left(&s->gb) < 0)
01156             return AVERROR_INVALIDDATA;
01157 
01158         for (l = 0; l < s->vq_start_subband[k]; l++) {
01159             int m;
01160 
01161             /* Select the mid-tread linear quantizer */
01162             int abits = s->bitalloc[k][l];
01163 
01164             float quant_step_size = quant_step_table[abits];
01165 
01166             /*
01167              * Determine quantization index code book and its type
01168              */
01169 
01170             /* Select quantization index code book */
01171             int sel = s->quant_index_huffman[k][abits];
01172 
01173             /*
01174              * Extract bits from the bit stream
01175              */
01176             if (!abits) {
01177                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
01178             } else {
01179                 /* Deal with transients */
01180                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
01181                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
01182                                s->scalefactor_adj[k][sel];
01183 
01184                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
01185                     if (abits <= 7) {
01186                         /* Block code */
01187                         int block_code1, block_code2, size, levels, err;
01188 
01189                         size   = abits_sizes[abits - 1];
01190                         levels = abits_levels[abits - 1];
01191 
01192                         block_code1 = get_bits(&s->gb, size);
01193                         block_code2 = get_bits(&s->gb, size);
01194                         err = decode_blockcodes(block_code1, block_code2,
01195                                                 levels, block);
01196                         if (err) {
01197                             av_log(s->avctx, AV_LOG_ERROR,
01198                                    "ERROR: block code look-up failed\n");
01199                             return AVERROR_INVALIDDATA;
01200                         }
01201                     } else {
01202                         /* no coding */
01203                         for (m = 0; m < 8; m++)
01204                             block[m] = get_sbits(&s->gb, abits - 3);
01205                     }
01206                 } else {
01207                     /* Huffman coded */
01208                     for (m = 0; m < 8; m++)
01209                         block[m] = get_bitalloc(&s->gb,
01210                                                 &dca_smpl_bitalloc[abits], sel);
01211                 }
01212 
01213                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
01214                                                        block, rscale, 8);
01215             }
01216 
01217             /*
01218              * Inverse ADPCM if in prediction mode
01219              */
01220             if (s->prediction_mode[k][l]) {
01221                 int n;
01222                 for (m = 0; m < 8; m++) {
01223                     for (n = 1; n <= 4; n++)
01224                         if (m >= n)
01225                             subband_samples[k][l][m] +=
01226                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01227                                  subband_samples[k][l][m - n] / 8192);
01228                         else if (s->predictor_history)
01229                             subband_samples[k][l][m] +=
01230                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01231                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
01232                 }
01233             }
01234         }
01235 
01236         /*
01237          * Decode VQ encoded high frequencies
01238          */
01239         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01240             /* 1 vector -> 32 samples but we only need the 8 samples
01241              * for this subsubframe. */
01242             int hfvq = s->high_freq_vq[k][l];
01243 
01244             if (!s->debug_flag & 0x01) {
01245                 av_log(s->avctx, AV_LOG_DEBUG,
01246                        "Stream with high frequencies VQ coding\n");
01247                 s->debug_flag |= 0x01;
01248             }
01249 
01250             int8x8_fmul_int32(subband_samples[k][l],
01251                               &high_freq_vq[hfvq][subsubframe * 8],
01252                               s->scale_factor[k][l][0]);
01253         }
01254     }
01255 
01256     /* Check for DSYNC after subsubframe */
01257     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
01258         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
01259 #ifdef TRACE
01260             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
01261 #endif
01262         } else {
01263             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
01264             return AVERROR_INVALIDDATA;
01265         }
01266     }
01267 
01268     /* Backup predictor history for adpcm */
01269     for (k = base_channel; k < s->prim_channels; k++)
01270         for (l = 0; l < s->vq_start_subband[k]; l++)
01271             memcpy(s->subband_samples_hist[k][l],
01272                    &subband_samples[k][l][4],
01273                    4 * sizeof(subband_samples[0][0][0]));
01274 
01275     return 0;
01276 }
01277 
01278 static int dca_filter_channels(DCAContext *s, int block_index)
01279 {
01280     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01281     int k;
01282 
01283     /* 32 subbands QMF */
01284     for (k = 0; k < s->prim_channels; k++) {
01285 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
01286                                             0, 8388608.0, 8388608.0 };*/
01287         qmf_32_subbands(s, k, subband_samples[k],
01288                         &s->samples[256 * s->channel_order_tab[k]],
01289                         M_SQRT1_2 * s->scale_bias /* pcm_to_double[s->source_pcm_res] */);
01290     }
01291 
01292     /* Down mixing */
01293     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
01294         dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
01295     }
01296 
01297     /* Generate LFE samples for this subsubframe FIXME!!! */
01298     if (s->output & DCA_LFE) {
01299         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
01300                               s->lfe_data + 2 * s->lfe * (block_index + 4),
01301                               &s->samples[256 * dca_lfe_index[s->amode]],
01302                               (1.0 / 256.0) * s->scale_bias);
01303         /* Outputs 20bits pcm samples */
01304     }
01305 
01306     return 0;
01307 }
01308 
01309 
01310 static int dca_subframe_footer(DCAContext *s, int base_channel)
01311 {
01312     int aux_data_count = 0, i;
01313 
01314     /*
01315      * Unpack optional information
01316      */
01317 
01318     /* presumably optional information only appears in the core? */
01319     if (!base_channel) {
01320         if (s->timestamp)
01321             skip_bits_long(&s->gb, 32);
01322 
01323         if (s->aux_data)
01324             aux_data_count = get_bits(&s->gb, 6);
01325 
01326         for (i = 0; i < aux_data_count; i++)
01327             get_bits(&s->gb, 8);
01328 
01329         if (s->crc_present && (s->downmix || s->dynrange))
01330             get_bits(&s->gb, 16);
01331     }
01332 
01333     return 0;
01334 }
01335 
01342 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
01343 {
01344     int ret;
01345 
01346     /* Sanity check */
01347     if (s->current_subframe >= s->subframes) {
01348         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
01349                s->current_subframe, s->subframes);
01350         return AVERROR_INVALIDDATA;
01351     }
01352 
01353     if (!s->current_subsubframe) {
01354 #ifdef TRACE
01355         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
01356 #endif
01357         /* Read subframe header */
01358         if ((ret = dca_subframe_header(s, base_channel, block_index)))
01359             return ret;
01360     }
01361 
01362     /* Read subsubframe */
01363 #ifdef TRACE
01364     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
01365 #endif
01366     if ((ret = dca_subsubframe(s, base_channel, block_index)))
01367         return ret;
01368 
01369     /* Update state */
01370     s->current_subsubframe++;
01371     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
01372         s->current_subsubframe = 0;
01373         s->current_subframe++;
01374     }
01375     if (s->current_subframe >= s->subframes) {
01376 #ifdef TRACE
01377         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
01378 #endif
01379         /* Read subframe footer */
01380         if ((ret = dca_subframe_footer(s, base_channel)))
01381             return ret;
01382     }
01383 
01384     return 0;
01385 }
01386 
01390 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
01391                                  int max_size)
01392 {
01393     uint32_t mrk;
01394     int i, tmp;
01395     const uint16_t *ssrc = (const uint16_t *) src;
01396     uint16_t *sdst = (uint16_t *) dst;
01397     PutBitContext pb;
01398 
01399     if ((unsigned) src_size > (unsigned) max_size) {
01400 //        av_log(NULL, AV_LOG_ERROR, "Input frame size larger than DCA_MAX_FRAME_SIZE!\n");
01401 //        return -1;
01402         src_size = max_size;
01403     }
01404 
01405     mrk = AV_RB32(src);
01406     switch (mrk) {
01407     case DCA_MARKER_RAW_BE:
01408         memcpy(dst, src, src_size);
01409         return src_size;
01410     case DCA_MARKER_RAW_LE:
01411         for (i = 0; i < (src_size + 1) >> 1; i++)
01412             *sdst++ = av_bswap16(*ssrc++);
01413         return src_size;
01414     case DCA_MARKER_14B_BE:
01415     case DCA_MARKER_14B_LE:
01416         init_put_bits(&pb, dst, max_size);
01417         for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
01418             tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
01419             put_bits(&pb, 14, tmp);
01420         }
01421         flush_put_bits(&pb);
01422         return (put_bits_count(&pb) + 7) >> 3;
01423     default:
01424         return AVERROR_INVALIDDATA;
01425     }
01426 }
01427 
01431 static int dca_exss_mask2count(int mask)
01432 {
01433     /* count bits that mean speaker pairs twice */
01434     return av_popcount(mask) +
01435            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
01436                                DCA_EXSS_FRONT_LEFT_RIGHT       |
01437                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
01438                                DCA_EXSS_WIDE_LEFT_RIGHT        |
01439                                DCA_EXSS_SIDE_LEFT_RIGHT        |
01440                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
01441                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
01442                                DCA_EXSS_REAR_LEFT_RIGHT        |
01443                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
01444 }
01445 
01449 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
01450 {
01451     int i;
01452 
01453     for (i = 0; i < channels; i++) {
01454         int mix_map_mask = get_bits(gb, out_ch);
01455         int num_coeffs = av_popcount(mix_map_mask);
01456         skip_bits_long(gb, num_coeffs * 6);
01457     }
01458 }
01459 
01463 static int dca_exss_parse_asset_header(DCAContext *s)
01464 {
01465     int header_pos = get_bits_count(&s->gb);
01466     int header_size;
01467     int channels;
01468     int embedded_stereo = 0;
01469     int embedded_6ch    = 0;
01470     int drc_code_present;
01471     int extensions_mask;
01472     int i, j;
01473 
01474     if (get_bits_left(&s->gb) < 16)
01475         return -1;
01476 
01477     /* We will parse just enough to get to the extensions bitmask with which
01478      * we can set the profile value. */
01479 
01480     header_size = get_bits(&s->gb, 9) + 1;
01481     skip_bits(&s->gb, 3); // asset index
01482 
01483     if (s->static_fields) {
01484         if (get_bits1(&s->gb))
01485             skip_bits(&s->gb, 4); // asset type descriptor
01486         if (get_bits1(&s->gb))
01487             skip_bits_long(&s->gb, 24); // language descriptor
01488 
01489         if (get_bits1(&s->gb)) {
01490             /* How can one fit 1024 bytes of text here if the maximum value
01491              * for the asset header size field above was 512 bytes? */
01492             int text_length = get_bits(&s->gb, 10) + 1;
01493             if (get_bits_left(&s->gb) < text_length * 8)
01494                 return -1;
01495             skip_bits_long(&s->gb, text_length * 8); // info text
01496         }
01497 
01498         skip_bits(&s->gb, 5); // bit resolution - 1
01499         skip_bits(&s->gb, 4); // max sample rate code
01500         channels = get_bits(&s->gb, 8) + 1;
01501 
01502         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
01503             int spkr_remap_sets;
01504             int spkr_mask_size = 16;
01505             int num_spkrs[7];
01506 
01507             if (channels > 2)
01508                 embedded_stereo = get_bits1(&s->gb);
01509             if (channels > 6)
01510                 embedded_6ch = get_bits1(&s->gb);
01511 
01512             if (get_bits1(&s->gb)) {
01513                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
01514                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
01515             }
01516 
01517             spkr_remap_sets = get_bits(&s->gb, 3);
01518 
01519             for (i = 0; i < spkr_remap_sets; i++) {
01520                 /* std layout mask for each remap set */
01521                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
01522             }
01523 
01524             for (i = 0; i < spkr_remap_sets; i++) {
01525                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
01526                 if (get_bits_left(&s->gb) < 0)
01527                     return -1;
01528 
01529                 for (j = 0; j < num_spkrs[i]; j++) {
01530                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
01531                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
01532                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
01533                 }
01534             }
01535 
01536         } else {
01537             skip_bits(&s->gb, 3); // representation type
01538         }
01539     }
01540 
01541     drc_code_present = get_bits1(&s->gb);
01542     if (drc_code_present)
01543         get_bits(&s->gb, 8); // drc code
01544 
01545     if (get_bits1(&s->gb))
01546         skip_bits(&s->gb, 5); // dialog normalization code
01547 
01548     if (drc_code_present && embedded_stereo)
01549         get_bits(&s->gb, 8); // drc stereo code
01550 
01551     if (s->mix_metadata && get_bits1(&s->gb)) {
01552         skip_bits(&s->gb, 1); // external mix
01553         skip_bits(&s->gb, 6); // post mix gain code
01554 
01555         if (get_bits(&s->gb, 2) != 3) // mixer drc code
01556             skip_bits(&s->gb, 3); // drc limit
01557         else
01558             skip_bits(&s->gb, 8); // custom drc code
01559 
01560         if (get_bits1(&s->gb)) // channel specific scaling
01561             for (i = 0; i < s->num_mix_configs; i++)
01562                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
01563         else
01564             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
01565 
01566         for (i = 0; i < s->num_mix_configs; i++) {
01567             if (get_bits_left(&s->gb) < 0)
01568                 return -1;
01569             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
01570             if (embedded_6ch)
01571                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
01572             if (embedded_stereo)
01573                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
01574         }
01575     }
01576 
01577     switch (get_bits(&s->gb, 2)) {
01578     case 0: extensions_mask = get_bits(&s->gb, 12); break;
01579     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
01580     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
01581     case 3: extensions_mask = 0; /* aux coding */   break;
01582     }
01583 
01584     /* not parsed further, we were only interested in the extensions mask */
01585 
01586     if (get_bits_left(&s->gb) < 0)
01587         return -1;
01588 
01589     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
01590         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
01591         return -1;
01592     }
01593     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
01594 
01595     if (extensions_mask & DCA_EXT_EXSS_XLL)
01596         s->profile = FF_PROFILE_DTS_HD_MA;
01597     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
01598                                 DCA_EXT_EXSS_XXCH))
01599         s->profile = FF_PROFILE_DTS_HD_HRA;
01600 
01601     if (!(extensions_mask & DCA_EXT_CORE))
01602         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
01603     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
01604         av_log(s->avctx, AV_LOG_WARNING,
01605                "DTS extensions detection mismatch (%d, %d)\n",
01606                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
01607 
01608     return 0;
01609 }
01610 
01614 static void dca_exss_parse_header(DCAContext *s)
01615 {
01616     int ss_index;
01617     int blownup;
01618     int num_audiop = 1;
01619     int num_assets = 1;
01620     int active_ss_mask[8];
01621     int i, j;
01622 
01623     if (get_bits_left(&s->gb) < 52)
01624         return;
01625 
01626     skip_bits(&s->gb, 8); // user data
01627     ss_index = get_bits(&s->gb, 2);
01628 
01629     blownup = get_bits1(&s->gb);
01630     skip_bits(&s->gb,  8 + 4 * blownup); // header_size
01631     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
01632 
01633     s->static_fields = get_bits1(&s->gb);
01634     if (s->static_fields) {
01635         skip_bits(&s->gb, 2); // reference clock code
01636         skip_bits(&s->gb, 3); // frame duration code
01637 
01638         if (get_bits1(&s->gb))
01639             skip_bits_long(&s->gb, 36); // timestamp
01640 
01641         /* a single stream can contain multiple audio assets that can be
01642          * combined to form multiple audio presentations */
01643 
01644         num_audiop = get_bits(&s->gb, 3) + 1;
01645         if (num_audiop > 1) {
01646             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
01647             /* ignore such streams for now */
01648             return;
01649         }
01650 
01651         num_assets = get_bits(&s->gb, 3) + 1;
01652         if (num_assets > 1) {
01653             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
01654             /* ignore such streams for now */
01655             return;
01656         }
01657 
01658         for (i = 0; i < num_audiop; i++)
01659             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
01660 
01661         for (i = 0; i < num_audiop; i++)
01662             for (j = 0; j <= ss_index; j++)
01663                 if (active_ss_mask[i] & (1 << j))
01664                     skip_bits(&s->gb, 8); // active asset mask
01665 
01666         s->mix_metadata = get_bits1(&s->gb);
01667         if (s->mix_metadata) {
01668             int mix_out_mask_size;
01669 
01670             skip_bits(&s->gb, 2); // adjustment level
01671             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
01672             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
01673 
01674             for (i = 0; i < s->num_mix_configs; i++) {
01675                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
01676                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
01677             }
01678         }
01679     }
01680 
01681     for (i = 0; i < num_assets; i++)
01682         skip_bits_long(&s->gb, 16 + 4 * blownup);  // asset size
01683 
01684     for (i = 0; i < num_assets; i++) {
01685         if (dca_exss_parse_asset_header(s))
01686             return;
01687     }
01688 
01689     /* not parsed further, we were only interested in the extensions mask
01690      * from the asset header */
01691 }
01692 
01697 static int dca_decode_frame(AVCodecContext *avctx, void *data,
01698                             int *got_frame_ptr, AVPacket *avpkt)
01699 {
01700     const uint8_t *buf = avpkt->data;
01701     int buf_size = avpkt->size;
01702 
01703     int lfe_samples;
01704     int num_core_channels = 0;
01705     int i, ret;
01706     float   *samples_flt;
01707     int16_t *samples_s16;
01708     DCAContext *s = avctx->priv_data;
01709     int channels;
01710     int core_ss_end;
01711 
01712 
01713     s->xch_present = 0;
01714 
01715     s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
01716                                                DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
01717     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
01718         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
01719         return AVERROR_INVALIDDATA;
01720     }
01721 
01722     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
01723     if ((ret = dca_parse_frame_header(s)) < 0) {
01724         //seems like the frame is corrupt, try with the next one
01725         return ret;
01726     }
01727     //set AVCodec values with parsed data
01728     avctx->sample_rate = s->sample_rate;
01729     avctx->bit_rate    = s->bit_rate;
01730     avctx->frame_size  = s->sample_blocks * 32;
01731 
01732     s->profile = FF_PROFILE_DTS;
01733 
01734     for (i = 0; i < (s->sample_blocks / 8); i++) {
01735         if ((ret = dca_decode_block(s, 0, i))) {
01736             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
01737             return ret;
01738         }
01739     }
01740 
01741     /* record number of core channels incase less than max channels are requested */
01742     num_core_channels = s->prim_channels;
01743 
01744     if (s->ext_coding)
01745         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
01746     else
01747         s->core_ext_mask = 0;
01748 
01749     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
01750 
01751     /* only scan for extensions if ext_descr was unknown or indicated a
01752      * supported XCh extension */
01753     if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
01754 
01755         /* if ext_descr was unknown, clear s->core_ext_mask so that the
01756          * extensions scan can fill it up */
01757         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
01758 
01759         /* extensions start at 32-bit boundaries into bitstream */
01760         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01761 
01762         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
01763             uint32_t bits = get_bits_long(&s->gb, 32);
01764 
01765             switch (bits) {
01766             case 0x5a5a5a5a: {
01767                 int ext_amode, xch_fsize;
01768 
01769                 s->xch_base_channel = s->prim_channels;
01770 
01771                 /* validate sync word using XCHFSIZE field */
01772                 xch_fsize = show_bits(&s->gb, 10);
01773                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
01774                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
01775                     continue;
01776 
01777                 /* skip length-to-end-of-frame field for the moment */
01778                 skip_bits(&s->gb, 10);
01779 
01780                 s->core_ext_mask |= DCA_EXT_XCH;
01781 
01782                 /* extension amode(number of channels in extension) should be 1 */
01783                 /* AFAIK XCh is not used for more channels */
01784                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
01785                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
01786                            " supported!\n", ext_amode);
01787                     continue;
01788                 }
01789 
01790                 /* much like core primary audio coding header */
01791                 dca_parse_audio_coding_header(s, s->xch_base_channel);
01792 
01793                 for (i = 0; i < (s->sample_blocks / 8); i++)
01794                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
01795                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
01796                         continue;
01797                     }
01798 
01799                 s->xch_present = 1;
01800                 break;
01801             }
01802             case 0x47004a03:
01803                 /* XXCh: extended channels */
01804                 /* usually found either in core or HD part in DTS-HD HRA streams,
01805                  * but not in DTS-ES which contains XCh extensions instead */
01806                 s->core_ext_mask |= DCA_EXT_XXCH;
01807                 break;
01808 
01809             case 0x1d95f262: {
01810                 int fsize96 = show_bits(&s->gb, 12) + 1;
01811                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
01812                     continue;
01813 
01814                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
01815                        get_bits_count(&s->gb));
01816                 skip_bits(&s->gb, 12);
01817                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
01818                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
01819 
01820                 s->core_ext_mask |= DCA_EXT_X96;
01821                 break;
01822             }
01823             }
01824 
01825             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01826         }
01827     } else {
01828         /* no supported extensions, skip the rest of the core substream */
01829         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
01830     }
01831 
01832     if (s->core_ext_mask & DCA_EXT_X96)
01833         s->profile = FF_PROFILE_DTS_96_24;
01834     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
01835         s->profile = FF_PROFILE_DTS_ES;
01836 
01837     /* check for ExSS (HD part) */
01838     if (s->dca_buffer_size - s->frame_size > 32 &&
01839         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
01840         dca_exss_parse_header(s);
01841 
01842     avctx->profile = s->profile;
01843 
01844     channels = s->prim_channels + !!s->lfe;
01845 
01846     if (s->amode < 16) {
01847         avctx->channel_layout = dca_core_channel_layout[s->amode];
01848 
01849         if (s->xch_present && (!avctx->request_channels ||
01850                                avctx->request_channels > num_core_channels + !!s->lfe)) {
01851             avctx->channel_layout |= AV_CH_BACK_CENTER;
01852             if (s->lfe) {
01853                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01854                 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
01855             } else {
01856                 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
01857             }
01858         } else {
01859             channels = num_core_channels + !!s->lfe;
01860             s->xch_present = 0; /* disable further xch processing */
01861             if (s->lfe) {
01862                 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01863                 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
01864             } else
01865                 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
01866         }
01867 
01868         if (channels > !!s->lfe &&
01869             s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
01870             return AVERROR_INVALIDDATA;
01871 
01872         if (avctx->request_channels == 2 && s->prim_channels > 2) {
01873             channels = 2;
01874             s->output = DCA_STEREO;
01875             avctx->channel_layout = AV_CH_LAYOUT_STEREO;
01876         }
01877     } else {
01878         av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
01879         return AVERROR_INVALIDDATA;
01880     }
01881 
01882 
01883     /* There is nothing that prevents a dts frame to change channel configuration
01884        but Libav doesn't support that so only set the channels if it is previously
01885        unset. Ideally during the first probe for channels the crc should be checked
01886        and only set avctx->channels when the crc is ok. Right now the decoder could
01887        set the channels based on a broken first frame.*/
01888     if (s->is_channels_set == 0) {
01889         s->is_channels_set = 1;
01890         avctx->channels = channels;
01891     }
01892     if (avctx->channels != channels) {
01893         av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
01894                "channels changing in stream. Skipping frame.\n");
01895         return AVERROR_PATCHWELCOME;
01896     }
01897 
01898     /* get output buffer */
01899     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
01900     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
01901         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01902         return ret;
01903     }
01904     samples_flt = (float *)   s->frame.data[0];
01905     samples_s16 = (int16_t *) s->frame.data[0];
01906 
01907     /* filter to get final output */
01908     for (i = 0; i < (s->sample_blocks / 8); i++) {
01909         dca_filter_channels(s, i);
01910 
01911         /* If this was marked as a DTS-ES stream we need to subtract back- */
01912         /* channel from SL & SR to remove matrixed back-channel signal */
01913         if ((s->source_pcm_res & 1) && s->xch_present) {
01914             float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel]     * 256;
01915             float *lt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
01916             float *rt_chan   = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
01917             s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
01918             s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
01919         }
01920 
01921         if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
01922             s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
01923                                          channels);
01924             samples_flt += 256 * channels;
01925         } else {
01926             s->fmt_conv.float_to_int16_interleave(samples_s16,
01927                                                   s->samples_chanptr, 256,
01928                                                   channels);
01929             samples_s16 += 256 * channels;
01930         }
01931     }
01932 
01933     /* update lfe history */
01934     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
01935     for (i = 0; i < 2 * s->lfe * 4; i++)
01936         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
01937 
01938     *got_frame_ptr    = 1;
01939     *(AVFrame *) data = s->frame;
01940 
01941     return buf_size;
01942 }
01943 
01944 
01945 
01952 static av_cold int dca_decode_init(AVCodecContext *avctx)
01953 {
01954     DCAContext *s = avctx->priv_data;
01955     int i;
01956 
01957     s->avctx = avctx;
01958     dca_init_vlcs();
01959 
01960     dsputil_init(&s->dsp, avctx);
01961     ff_mdct_init(&s->imdct, 6, 1, 1.0);
01962     ff_synth_filter_init(&s->synth);
01963     ff_dcadsp_init(&s->dcadsp);
01964     ff_fmt_convert_init(&s->fmt_conv, avctx);
01965 
01966     for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
01967         s->samples_chanptr[i] = s->samples + i * 256;
01968 
01969     if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
01970         avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
01971         s->scale_bias     = 1.0 / 32768.0;
01972     } else {
01973         avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01974         s->scale_bias     = 1.0;
01975     }
01976 
01977     /* allow downmixing to stereo */
01978     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
01979         avctx->request_channels == 2) {
01980         avctx->channels = avctx->request_channels;
01981     }
01982 
01983     avcodec_get_frame_defaults(&s->frame);
01984     avctx->coded_frame = &s->frame;
01985 
01986     return 0;
01987 }
01988 
01989 static av_cold int dca_decode_end(AVCodecContext *avctx)
01990 {
01991     DCAContext *s = avctx->priv_data;
01992     ff_mdct_end(&s->imdct);
01993     return 0;
01994 }
01995 
01996 static const AVProfile profiles[] = {
01997     { FF_PROFILE_DTS,        "DTS"        },
01998     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
01999     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
02000     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
02001     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
02002     { FF_PROFILE_UNKNOWN },
02003 };
02004 
02005 AVCodec ff_dca_decoder = {
02006     .name            = "dca",
02007     .type            = AVMEDIA_TYPE_AUDIO,
02008     .id              = CODEC_ID_DTS,
02009     .priv_data_size  = sizeof(DCAContext),
02010     .init            = dca_decode_init,
02011     .decode          = dca_decode_frame,
02012     .close           = dca_decode_end,
02013     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
02014     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
02015     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
02016                                                        AV_SAMPLE_FMT_S16,
02017                                                        AV_SAMPLE_FMT_NONE },
02018     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
02019 };