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