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