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