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