FFmpeg: libavcodec/dcadec.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/channel_layout.h"
00030 #include "libavutil/common.h"
00031 #include "libavutil/float_dsp.h"
00032 #include "libavutil/intmath.h"
00033 #include "libavutil/intreadwrite.h"
00034 #include "libavutil/mathematics.h"
00035 #include "libavutil/samplefmt.h"
00036 #include "avcodec.h"
00037 #include "dsputil.h"
00038 #include "fft.h"
00039 #include "get_bits.h"
00040 #include "put_bits.h"
00041 #include "dcadata.h"
00042 #include "dcahuff.h"
00043 #include "dca.h"
00044 #include "dca_parser.h"
00045 #include "synth_filter.h"
00046 #include "dcadsp.h"
00047 #include "fmtconvert.h"
00048 #include "internal.h"
00049 
00050 #if ARCH_ARM
00051 #   include "arm/dca.h"
00052 #endif
00053 
00054 //#define TRACE
00055 
00056 #define DCA_PRIM_CHANNELS_MAX  (7)
00057 #define DCA_SUBBANDS          (64)
00058 #define DCA_ABITS_MAX         (32)      /* Should be 28 */
00059 #define DCA_SUBSUBFRAMES_MAX   (4)
00060 #define DCA_SUBFRAMES_MAX     (16)
00061 #define DCA_BLOCKS_MAX        (16)
00062 #define DCA_LFE_MAX            (3)
00063 #define DCA_CHSETS_MAX         (4)
00064 #define DCA_CHSET_CHANS_MAX    (8)
00065 
00066 enum DCAMode {
00067     DCA_MONO = 0,
00068     DCA_CHANNEL,
00069     DCA_STEREO,
00070     DCA_STEREO_SUMDIFF,
00071     DCA_STEREO_TOTAL,
00072     DCA_3F,
00073     DCA_2F1R,
00074     DCA_3F1R,
00075     DCA_2F2R,
00076     DCA_3F2R,
00077     DCA_4F2R
00078 };
00079 
00080 /* these are unconfirmed but should be mostly correct */
00081 enum DCAExSSSpeakerMask {
00082     DCA_EXSS_FRONT_CENTER          = 0x0001,
00083     DCA_EXSS_FRONT_LEFT_RIGHT      = 0x0002,
00084     DCA_EXSS_SIDE_REAR_LEFT_RIGHT  = 0x0004,
00085     DCA_EXSS_LFE                   = 0x0008,
00086     DCA_EXSS_REAR_CENTER           = 0x0010,
00087     DCA_EXSS_FRONT_HIGH_LEFT_RIGHT = 0x0020,
00088     DCA_EXSS_REAR_LEFT_RIGHT       = 0x0040,
00089     DCA_EXSS_FRONT_HIGH_CENTER     = 0x0080,
00090     DCA_EXSS_OVERHEAD              = 0x0100,
00091     DCA_EXSS_CENTER_LEFT_RIGHT     = 0x0200,
00092     DCA_EXSS_WIDE_LEFT_RIGHT       = 0x0400,
00093     DCA_EXSS_SIDE_LEFT_RIGHT       = 0x0800,
00094     DCA_EXSS_LFE2                  = 0x1000,
00095     DCA_EXSS_SIDE_HIGH_LEFT_RIGHT  = 0x2000,
00096     DCA_EXSS_REAR_HIGH_CENTER      = 0x4000,
00097     DCA_EXSS_REAR_HIGH_LEFT_RIGHT  = 0x8000,
00098 };
00099 
00100 enum DCAXxchSpeakerMask {
00101     DCA_XXCH_FRONT_CENTER          = 0x0000001,
00102     DCA_XXCH_FRONT_LEFT            = 0x0000002,
00103     DCA_XXCH_FRONT_RIGHT           = 0x0000004,
00104     DCA_XXCH_SIDE_REAR_LEFT        = 0x0000008,
00105     DCA_XXCH_SIDE_REAR_RIGHT       = 0x0000010,
00106     DCA_XXCH_LFE1                  = 0x0000020,
00107     DCA_XXCH_REAR_CENTER           = 0x0000040,
00108     DCA_XXCH_SURROUND_REAR_LEFT    = 0x0000080,
00109     DCA_XXCH_SURROUND_REAR_RIGHT   = 0x0000100,
00110     DCA_XXCH_SIDE_SURROUND_LEFT    = 0x0000200,
00111     DCA_XXCH_SIDE_SURROUND_RIGHT   = 0x0000400,
00112     DCA_XXCH_FRONT_CENTER_LEFT     = 0x0000800,
00113     DCA_XXCH_FRONT_CENTER_RIGHT    = 0x0001000,
00114     DCA_XXCH_FRONT_HIGH_LEFT       = 0x0002000,
00115     DCA_XXCH_FRONT_HIGH_CENTER     = 0x0004000,
00116     DCA_XXCH_FRONT_HIGH_RIGHT      = 0x0008000,
00117     DCA_XXCH_LFE2                  = 0x0010000,
00118     DCA_XXCH_SIDE_FRONT_LEFT       = 0x0020000,
00119     DCA_XXCH_SIDE_FRONT_RIGHT      = 0x0040000,
00120     DCA_XXCH_OVERHEAD              = 0x0080000,
00121     DCA_XXCH_SIDE_HIGH_LEFT        = 0x0100000,
00122     DCA_XXCH_SIDE_HIGH_RIGHT       = 0x0200000,
00123     DCA_XXCH_REAR_HIGH_CENTER      = 0x0400000,
00124     DCA_XXCH_REAR_HIGH_LEFT        = 0x0800000,
00125     DCA_XXCH_REAR_HIGH_RIGHT       = 0x1000000,
00126     DCA_XXCH_REAR_LOW_CENTER       = 0x2000000,
00127     DCA_XXCH_REAR_LOW_LEFT         = 0x4000000,
00128     DCA_XXCH_REAR_LOW_RIGHT        = 0x8000000,
00129 };
00130 
00131 static const uint32_t map_xxch_to_native[28] = {
00132     AV_CH_FRONT_CENTER,
00133     AV_CH_FRONT_LEFT,
00134     AV_CH_FRONT_RIGHT,
00135     AV_CH_SIDE_LEFT,
00136     AV_CH_SIDE_RIGHT,
00137     AV_CH_LOW_FREQUENCY,
00138     AV_CH_BACK_CENTER,
00139     AV_CH_BACK_LEFT,
00140     AV_CH_BACK_RIGHT,
00141     AV_CH_SIDE_LEFT,           /* side surround left -- dup sur side L */
00142     AV_CH_SIDE_RIGHT,          /* side surround right -- dup sur side R */
00143     AV_CH_FRONT_LEFT_OF_CENTER,
00144     AV_CH_FRONT_RIGHT_OF_CENTER,
00145     AV_CH_TOP_FRONT_LEFT,
00146     AV_CH_TOP_FRONT_CENTER,
00147     AV_CH_TOP_FRONT_RIGHT,
00148     AV_CH_LOW_FREQUENCY,        /* lfe2 -- duplicate lfe1 position */
00149     AV_CH_FRONT_LEFT_OF_CENTER, /* side front left -- dup front cntr L */
00150     AV_CH_FRONT_RIGHT_OF_CENTER,/* side front right -- dup front cntr R */
00151     AV_CH_TOP_CENTER,           /* overhead */
00152     AV_CH_TOP_FRONT_LEFT,       /* side high left -- dup */
00153     AV_CH_TOP_FRONT_RIGHT,      /* side high right -- dup */
00154     AV_CH_TOP_BACK_CENTER,
00155     AV_CH_TOP_BACK_LEFT,
00156     AV_CH_TOP_BACK_RIGHT,
00157     AV_CH_BACK_CENTER,          /* rear low center -- dup */
00158     AV_CH_BACK_LEFT,            /* rear low left -- dup */
00159     AV_CH_BACK_RIGHT            /* read low right -- dup  */
00160 };
00161 
00162 enum DCAExtensionMask {
00163     DCA_EXT_CORE       = 0x001, 
00164     DCA_EXT_XXCH       = 0x002, 
00165     DCA_EXT_X96        = 0x004, 
00166     DCA_EXT_XCH        = 0x008, 
00167     DCA_EXT_EXSS_CORE  = 0x010, 
00168     DCA_EXT_EXSS_XBR   = 0x020, 
00169     DCA_EXT_EXSS_XXCH  = 0x040, 
00170     DCA_EXT_EXSS_X96   = 0x080, 
00171     DCA_EXT_EXSS_LBR   = 0x100, 
00172     DCA_EXT_EXSS_XLL   = 0x200, 
00173 };
00174 
00175 /* -1 are reserved or unknown */
00176 static const int dca_ext_audio_descr_mask[] = {
00177     DCA_EXT_XCH,
00178     -1,
00179     DCA_EXT_X96,
00180     DCA_EXT_XCH | DCA_EXT_X96,
00181     -1,
00182     -1,
00183     DCA_EXT_XXCH,
00184     -1,
00185 };
00186 
00187 /* extensions that reside in core substream */
00188 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
00189 
00190 /* Tables for mapping dts channel configurations to libavcodec multichannel api.
00191  * Some compromises have been made for special configurations. Most configurations
00192  * are never used so complete accuracy is not needed.
00193  *
00194  * L = left, R = right, C = center, S = surround, F = front, R = rear, T = total, OV = overhead.
00195  * S  -> side, when both rear and back are configured move one of them to the side channel
00196  * OV -> center back
00197  * All 2 channel configurations -> AV_CH_LAYOUT_STEREO
00198  */
00199 static const uint64_t dca_core_channel_layout[] = {
00200     AV_CH_FRONT_CENTER,                                                     
00201     AV_CH_LAYOUT_STEREO,                                                    
00202     AV_CH_LAYOUT_STEREO,                                                    
00203     AV_CH_LAYOUT_STEREO,                                                    
00204     AV_CH_LAYOUT_STEREO,                                                    
00205     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER,                               
00206     AV_CH_LAYOUT_STEREO | AV_CH_BACK_CENTER,                                
00207     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_BACK_CENTER,           
00208     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,               
00209 
00210     AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT |
00211     AV_CH_SIDE_RIGHT,                                                       
00212 
00213     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
00214     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER,               
00215 
00216     AV_CH_LAYOUT_STEREO | AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT |
00217     AV_CH_FRONT_CENTER  | AV_CH_BACK_CENTER,                                
00218 
00219     AV_CH_FRONT_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
00220     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_BACK_CENTER   |
00221     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     
00222 
00223     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
00224     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
00225     AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,                                     
00226 
00227     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER |
00228     AV_CH_LAYOUT_STEREO | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT |
00229     AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT,                                     
00230 
00231     AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_CENTER   |
00232     AV_CH_FRONT_RIGHT_OF_CENTER | AV_CH_LAYOUT_STEREO |
00233     AV_CH_SIDE_LEFT | AV_CH_BACK_CENTER | AV_CH_SIDE_RIGHT,                 
00234 };
00235 
00236 static const int8_t dca_lfe_index[] = {
00237     1, 2, 2, 2, 2, 3, 2, 3, 2, 3, 2, 3, 1, 3, 2, 3
00238 };
00239 
00240 static const int8_t dca_channel_reorder_lfe[][9] = {
00241     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
00242     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00243     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00244     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00245     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00246     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
00247     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00248     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
00249     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
00250     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
00251     { 3,  4,  0,  1,  5,  6, -1, -1, -1},
00252     { 2,  0,  1,  4,  5,  6, -1, -1, -1},
00253     { 0,  6,  4,  5,  2,  3, -1, -1, -1},
00254     { 4,  2,  5,  0,  1,  6,  7, -1, -1},
00255     { 5,  6,  0,  1,  7,  3,  8,  4, -1},
00256     { 4,  2,  5,  0,  1,  6,  8,  7, -1},
00257 };
00258 
00259 static const int8_t dca_channel_reorder_lfe_xch[][9] = {
00260     { 0,  2, -1, -1, -1, -1, -1, -1, -1},
00261     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00262     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00263     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00264     { 0,  1,  3, -1, -1, -1, -1, -1, -1},
00265     { 2,  0,  1,  4, -1, -1, -1, -1, -1},
00266     { 0,  1,  3,  4, -1, -1, -1, -1, -1},
00267     { 2,  0,  1,  4,  5, -1, -1, -1, -1},
00268     { 0,  1,  4,  5,  3, -1, -1, -1, -1},
00269     { 2,  0,  1,  5,  6,  4, -1, -1, -1},
00270     { 3,  4,  0,  1,  6,  7,  5, -1, -1},
00271     { 2,  0,  1,  4,  5,  6,  7, -1, -1},
00272     { 0,  6,  4,  5,  2,  3,  7, -1, -1},
00273     { 4,  2,  5,  0,  1,  7,  8,  6, -1},
00274     { 5,  6,  0,  1,  8,  3,  9,  4,  7},
00275     { 4,  2,  5,  0,  1,  6,  9,  8,  7},
00276 };
00277 
00278 static const int8_t dca_channel_reorder_nolfe[][9] = {
00279     { 0, -1, -1, -1, -1, -1, -1, -1, -1},
00280     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00281     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00282     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00283     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00284     { 2,  0,  1, -1, -1, -1, -1, -1, -1},
00285     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00286     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
00287     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
00288     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
00289     { 2,  3,  0,  1,  4,  5, -1, -1, -1},
00290     { 2,  0,  1,  3,  4,  5, -1, -1, -1},
00291     { 0,  5,  3,  4,  1,  2, -1, -1, -1},
00292     { 3,  2,  4,  0,  1,  5,  6, -1, -1},
00293     { 4,  5,  0,  1,  6,  2,  7,  3, -1},
00294     { 3,  2,  4,  0,  1,  5,  7,  6, -1},
00295 };
00296 
00297 static const int8_t dca_channel_reorder_nolfe_xch[][9] = {
00298     { 0,  1, -1, -1, -1, -1, -1, -1, -1},
00299     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00300     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00301     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00302     { 0,  1,  2, -1, -1, -1, -1, -1, -1},
00303     { 2,  0,  1,  3, -1, -1, -1, -1, -1},
00304     { 0,  1,  2,  3, -1, -1, -1, -1, -1},
00305     { 2,  0,  1,  3,  4, -1, -1, -1, -1},
00306     { 0,  1,  3,  4,  2, -1, -1, -1, -1},
00307     { 2,  0,  1,  4,  5,  3, -1, -1, -1},
00308     { 2,  3,  0,  1,  5,  6,  4, -1, -1},
00309     { 2,  0,  1,  3,  4,  5,  6, -1, -1},
00310     { 0,  5,  3,  4,  1,  2,  6, -1, -1},
00311     { 3,  2,  4,  0,  1,  6,  7,  5, -1},
00312     { 4,  5,  0,  1,  7,  2,  8,  3,  6},
00313     { 3,  2,  4,  0,  1,  5,  8,  7,  6},
00314 };
00315 
00316 #define DCA_DOLBY                  101           /* FIXME */
00317 
00318 #define DCA_CHANNEL_BITS             6
00319 #define DCA_CHANNEL_MASK          0x3F
00320 
00321 #define DCA_LFE                   0x80
00322 
00323 #define HEADER_SIZE                 14
00324 
00325 #define DCA_MAX_FRAME_SIZE       16384
00326 #define DCA_MAX_EXSS_HEADER_SIZE  4096
00327 
00328 #define DCA_BUFFER_PADDING_SIZE   1024
00329 
00331 typedef struct {
00332     int offset;                 
00333     int maxbits[8];             
00334     int wrap;                   
00335     VLC vlc[8];                 
00336 } BitAlloc;
00337 
00338 static BitAlloc dca_bitalloc_index;    
00339 static BitAlloc dca_tmode;             
00340 static BitAlloc dca_scalefactor;       
00341 static BitAlloc dca_smpl_bitalloc[11]; 
00342 
00343 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba,
00344                                          int idx)
00345 {
00346     return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) +
00347            ba->offset;
00348 }
00349 
00350 typedef struct {
00351     AVCodecContext *avctx;
00352     AVFrame frame;
00353     /* Frame header */
00354     int frame_type;             
00355     int samples_deficit;        
00356     int crc_present;            
00357     int sample_blocks;          
00358     int frame_size;             
00359     int amode;                  
00360     int sample_rate;            
00361     int bit_rate;               
00362     int bit_rate_index;         
00363 
00364     int downmix;                
00365     int dynrange;               
00366     int timestamp;              
00367     int aux_data;               
00368     int hdcd;                   
00369     int ext_descr;              
00370     int ext_coding;             
00371     int aspf;                   
00372     int lfe;                    
00373     int predictor_history;      
00374     int header_crc;             
00375     int multirate_inter;        
00376     int version;                
00377     int copy_history;           
00378     int source_pcm_res;         
00379     int front_sum;              
00380     int surround_sum;           
00381     int dialog_norm;            
00382 
00383     /* Primary audio coding header */
00384     int subframes;              
00385     int total_channels;         
00386     int prim_channels;          
00387     int subband_activity[DCA_PRIM_CHANNELS_MAX];    
00388     int vq_start_subband[DCA_PRIM_CHANNELS_MAX];    
00389     int joint_intensity[DCA_PRIM_CHANNELS_MAX];     
00390     int transient_huffman[DCA_PRIM_CHANNELS_MAX];   
00391     int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX]; 
00392     int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];    
00393     int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX]; 
00394     float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];   
00395 
00396     /* Primary audio coding side information */
00397     int subsubframes[DCA_SUBFRAMES_MAX];                         
00398     int partial_samples[DCA_SUBFRAMES_MAX];                      
00399     int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    
00400     int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];      
00401     int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];           
00402     int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];    
00403     int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];    
00404     int joint_huff[DCA_PRIM_CHANNELS_MAX];                       
00405     int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS]; 
00406     int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];                  
00407     int dynrange_coef;                                           
00408 
00409     int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];       
00410 
00411     float lfe_data[2 * DCA_LFE_MAX * (DCA_BLOCKS_MAX + 4)];      
00412     int lfe_scale_factor;
00413 
00414     /* Subband samples history (for ADPCM) */
00415     DECLARE_ALIGNED(16, float, subband_samples_hist)[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
00416     DECLARE_ALIGNED(32, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
00417     DECLARE_ALIGNED(32, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
00418     int hist_index[DCA_PRIM_CHANNELS_MAX];
00419     DECLARE_ALIGNED(32, float, raXin)[32];
00420 
00421     int output;                 
00422 
00423     DECLARE_ALIGNED(32, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
00424     float *samples_chanptr[DCA_PRIM_CHANNELS_MAX + 1];
00425     float *extra_channels[DCA_PRIM_CHANNELS_MAX + 1];
00426     uint8_t *extra_channels_buffer;
00427     unsigned int extra_channels_buffer_size;
00428 
00429     uint8_t dca_buffer[DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE + DCA_BUFFER_PADDING_SIZE];
00430     int dca_buffer_size;        
00431 
00432     const int8_t *channel_order_tab;  
00433     GetBitContext gb;
00434     /* Current position in DCA frame */
00435     int current_subframe;
00436     int current_subsubframe;
00437 
00438     int core_ext_mask;          
00439 
00440     /* XCh extension information */
00441     int xch_present;            
00442     int xch_base_channel;       
00443 
00444     /* XXCH extension information */
00445     int xxch_chset;
00446     int xxch_nbits_spk_mask;
00447     uint32_t xxch_core_spkmask;
00448     uint32_t xxch_spk_masks[4]; /* speaker masks, last element is core mask */
00449     int xxch_chset_nch[4];
00450     float xxch_dmix_sf[DCA_CHSETS_MAX];
00451 
00452     uint32_t xxch_dmix_embedded;  /* lower layer has mix pre-embedded, per chset */
00453     float xxch_dmix_coeff[DCA_PRIM_CHANNELS_MAX][32]; /* worst case sizing */
00454 
00455     int8_t xxch_order_tab[32];
00456     int8_t lfe_index;
00457 
00458     /* ExSS header parser */
00459     int static_fields;          
00460     int mix_metadata;           
00461     int num_mix_configs;        
00462     int mix_config_num_ch[4];   
00463 
00464     int profile;
00465 
00466     int debug_flag;             
00467     AVFloatDSPContext fdsp;
00468     FFTContext imdct;
00469     SynthFilterContext synth;
00470     DCADSPContext dcadsp;
00471     FmtConvertContext fmt_conv;
00472 } DCAContext;
00473 
00474 static const uint16_t dca_vlc_offs[] = {
00475         0,   512,   640,   768,  1282,  1794,  2436,  3080,  3770,  4454,  5364,
00476      5372,  5380,  5388,  5392,  5396,  5412,  5420,  5428,  5460,  5492,  5508,
00477      5572,  5604,  5668,  5796,  5860,  5892,  6412,  6668,  6796,  7308,  7564,
00478      7820,  8076,  8620,  9132,  9388,  9910, 10166, 10680, 11196, 11726, 12240,
00479     12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
00480     18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
00481 };
00482 
00483 static av_cold void dca_init_vlcs(void)
00484 {
00485     static int vlcs_initialized = 0;
00486     int i, j, c = 14;
00487     static VLC_TYPE dca_table[23622][2];
00488 
00489     if (vlcs_initialized)
00490         return;
00491 
00492     dca_bitalloc_index.offset = 1;
00493     dca_bitalloc_index.wrap = 2;
00494     for (i = 0; i < 5; i++) {
00495         dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
00496         dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
00497         init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
00498                  bitalloc_12_bits[i], 1, 1,
00499                  bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00500     }
00501     dca_scalefactor.offset = -64;
00502     dca_scalefactor.wrap = 2;
00503     for (i = 0; i < 5; i++) {
00504         dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
00505         dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
00506         init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
00507                  scales_bits[i], 1, 1,
00508                  scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00509     }
00510     dca_tmode.offset = 0;
00511     dca_tmode.wrap = 1;
00512     for (i = 0; i < 4; i++) {
00513         dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
00514         dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
00515         init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
00516                  tmode_bits[i], 1, 1,
00517                  tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00518     }
00519 
00520     for (i = 0; i < 10; i++)
00521         for (j = 0; j < 7; j++) {
00522             if (!bitalloc_codes[i][j])
00523                 break;
00524             dca_smpl_bitalloc[i + 1].offset                 = bitalloc_offsets[i];
00525             dca_smpl_bitalloc[i + 1].wrap                   = 1 + (j > 4);
00526             dca_smpl_bitalloc[i + 1].vlc[j].table           = &dca_table[dca_vlc_offs[c]];
00527             dca_smpl_bitalloc[i + 1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
00528 
00529             init_vlc(&dca_smpl_bitalloc[i + 1].vlc[j], bitalloc_maxbits[i][j],
00530                      bitalloc_sizes[i],
00531                      bitalloc_bits[i][j], 1, 1,
00532                      bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
00533             c++;
00534         }
00535     vlcs_initialized = 1;
00536 }
00537 
00538 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
00539 {
00540     while (len--)
00541         *dst++ = get_bits(gb, bits);
00542 }
00543 
00544 static inline int dca_xxch2index(DCAContext *s, int xxch_ch)
00545 {
00546     int i, base, mask;
00547 
00548     /* locate channel set containing the channel */
00549     for (i = -1, base = 0, mask = (s->xxch_core_spkmask & ~DCA_XXCH_LFE1);
00550          i <= s->xxch_chset && !(mask & xxch_ch); mask = s->xxch_spk_masks[++i])
00551         base += av_popcount(mask);
00552 
00553     return base + av_popcount(mask & (xxch_ch - 1));
00554 }
00555 
00556 static int dca_parse_audio_coding_header(DCAContext *s, int base_channel,
00557                                          int xxch)
00558 {
00559     int i, j;
00560     static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
00561     static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
00562     static const int thr[11]    = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
00563     int hdr_pos = 0, hdr_size = 0;
00564     float sign, mag, scale_factor;
00565     int this_chans, acc_mask;
00566     int embedded_downmix;
00567     int nchans, mask[8];
00568     int coeff, ichan;
00569 
00570     /* xxch has arbitrary sized audio coding headers */
00571     if (xxch) {
00572         hdr_pos  = get_bits_count(&s->gb);
00573         hdr_size = get_bits(&s->gb, 7) + 1;
00574     }
00575 
00576     nchans = get_bits(&s->gb, 3) + 1;
00577     s->total_channels = nchans + base_channel;
00578     s->prim_channels  = s->total_channels;
00579 
00580     /* obtain speaker layout mask & downmix coefficients for XXCH */
00581     if (xxch) {
00582         acc_mask = s->xxch_core_spkmask;
00583 
00584         this_chans = get_bits(&s->gb, s->xxch_nbits_spk_mask - 6) << 6;
00585         s->xxch_spk_masks[s->xxch_chset] = this_chans;
00586         s->xxch_chset_nch[s->xxch_chset] = nchans;
00587 
00588         for (i = 0; i <= s->xxch_chset; i++)
00589             acc_mask |= s->xxch_spk_masks[i];
00590 
00591         /* check for downmixing information */
00592         if (get_bits1(&s->gb)) {
00593             embedded_downmix = get_bits1(&s->gb);
00594             scale_factor     =
00595                1.0f / dca_downmix_scale_factors[(get_bits(&s->gb, 6) - 1) << 2];
00596 
00597             s->xxch_dmix_sf[s->xxch_chset] = scale_factor;
00598 
00599             for (i = base_channel; i < s->prim_channels; i++) {
00600                 mask[i] = get_bits(&s->gb, s->xxch_nbits_spk_mask);
00601             }
00602 
00603             for (j = base_channel; j < s->prim_channels; j++) {
00604                 memset(s->xxch_dmix_coeff[j], 0, sizeof(s->xxch_dmix_coeff[0]));
00605                 s->xxch_dmix_embedded |= (embedded_downmix << j);
00606                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
00607                     if (mask[j] & (1 << i)) {
00608                         if ((1 << i) == DCA_XXCH_LFE1) {
00609                             av_log(s->avctx, AV_LOG_WARNING,
00610                                    "DCA-XXCH: dmix to LFE1 not supported.\n");
00611                             continue;
00612                         }
00613 
00614                         coeff = get_bits(&s->gb, 7);
00615                         sign  = (coeff & 64) ? 1.0 : -1.0;
00616                         mag   = dca_downmix_scale_factors[((coeff & 63) - 1) << 2];
00617                         ichan = dca_xxch2index(s, 1 << i);
00618                         s->xxch_dmix_coeff[j][ichan] = sign * mag;
00619                     }
00620                 }
00621             }
00622         }
00623     }
00624 
00625     if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
00626         s->prim_channels = DCA_PRIM_CHANNELS_MAX;
00627 
00628 
00629     for (i = base_channel; i < s->prim_channels; i++) {
00630         s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
00631         if (s->subband_activity[i] > DCA_SUBBANDS)
00632             s->subband_activity[i] = DCA_SUBBANDS;
00633     }
00634     for (i = base_channel; i < s->prim_channels; i++) {
00635         s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
00636         if (s->vq_start_subband[i] > DCA_SUBBANDS)
00637             s->vq_start_subband[i] = DCA_SUBBANDS;
00638     }
00639     get_array(&s->gb, s->joint_intensity + base_channel,     s->prim_channels - base_channel, 3);
00640     get_array(&s->gb, s->transient_huffman + base_channel,   s->prim_channels - base_channel, 2);
00641     get_array(&s->gb, s->scalefactor_huffman + base_channel, s->prim_channels - base_channel, 3);
00642     get_array(&s->gb, s->bitalloc_huffman + base_channel,    s->prim_channels - base_channel, 3);
00643 
00644     /* Get codebooks quantization indexes */
00645     if (!base_channel)
00646         memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
00647     for (j = 1; j < 11; j++)
00648         for (i = base_channel; i < s->prim_channels; i++)
00649             s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
00650 
00651     /* Get scale factor adjustment */
00652     for (j = 0; j < 11; j++)
00653         for (i = base_channel; i < s->prim_channels; i++)
00654             s->scalefactor_adj[i][j] = 1;
00655 
00656     for (j = 1; j < 11; j++)
00657         for (i = base_channel; i < s->prim_channels; i++)
00658             if (s->quant_index_huffman[i][j] < thr[j])
00659                 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
00660 
00661     if (!xxch) {
00662         if (s->crc_present) {
00663             /* Audio header CRC check */
00664             get_bits(&s->gb, 16);
00665         }
00666     } else {
00667         /* Skip to the end of the header, also ignore CRC if present  */
00668         i = get_bits_count(&s->gb);
00669         if (hdr_pos + 8 * hdr_size > i)
00670             skip_bits_long(&s->gb, hdr_pos + 8 * hdr_size - i);
00671     }
00672 
00673     s->current_subframe    = 0;
00674     s->current_subsubframe = 0;
00675 
00676 #ifdef TRACE
00677     av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
00678     av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
00679     for (i = base_channel; i < s->prim_channels; i++) {
00680         av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n",
00681                s->subband_activity[i]);
00682         av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n",
00683                s->vq_start_subband[i]);
00684         av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n",
00685                s->joint_intensity[i]);
00686         av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n",
00687                s->transient_huffman[i]);
00688         av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n",
00689                s->scalefactor_huffman[i]);
00690         av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n",
00691                s->bitalloc_huffman[i]);
00692         av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
00693         for (j = 0; j < 11; j++)
00694             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->quant_index_huffman[i][j]);
00695         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00696         av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
00697         for (j = 0; j < 11; j++)
00698             av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
00699         av_log(s->avctx, AV_LOG_DEBUG, "\n");
00700     }
00701 #endif
00702 
00703     return 0;
00704 }
00705 
00706 static int dca_parse_frame_header(DCAContext *s)
00707 {
00708     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
00709 
00710     /* Sync code */
00711     skip_bits_long(&s->gb, 32);
00712 
00713     /* Frame header */
00714     s->frame_type        = get_bits(&s->gb, 1);
00715     s->samples_deficit   = get_bits(&s->gb, 5) + 1;
00716     s->crc_present       = get_bits(&s->gb, 1);
00717     s->sample_blocks     = get_bits(&s->gb, 7) + 1;
00718     s->frame_size        = get_bits(&s->gb, 14) + 1;
00719     if (s->frame_size < 95)
00720         return AVERROR_INVALIDDATA;
00721     s->amode             = get_bits(&s->gb, 6);
00722     s->sample_rate       = avpriv_dca_sample_rates[get_bits(&s->gb, 4)];
00723     if (!s->sample_rate)
00724         return AVERROR_INVALIDDATA;
00725     s->bit_rate_index    = get_bits(&s->gb, 5);
00726     s->bit_rate          = dca_bit_rates[s->bit_rate_index];
00727     if (!s->bit_rate)
00728         return AVERROR_INVALIDDATA;
00729 
00730     s->downmix           = get_bits(&s->gb, 1); /* note: this is FixedBit == 0 */
00731     s->dynrange          = get_bits(&s->gb, 1);
00732     s->timestamp         = get_bits(&s->gb, 1);
00733     s->aux_data          = get_bits(&s->gb, 1);
00734     s->hdcd              = get_bits(&s->gb, 1);
00735     s->ext_descr         = get_bits(&s->gb, 3);
00736     s->ext_coding        = get_bits(&s->gb, 1);
00737     s->aspf              = get_bits(&s->gb, 1);
00738     s->lfe               = get_bits(&s->gb, 2);
00739     s->predictor_history = get_bits(&s->gb, 1);
00740 
00741     if (s->lfe == 3) {
00742         s->lfe = 0;
00743         av_log_ask_for_sample(s->avctx, "LFE is 3\n");
00744         return AVERROR_PATCHWELCOME;
00745     }
00746 
00747     /* TODO: check CRC */
00748     if (s->crc_present)
00749         s->header_crc    = get_bits(&s->gb, 16);
00750 
00751     s->multirate_inter   = get_bits(&s->gb, 1);
00752     s->version           = get_bits(&s->gb, 4);
00753     s->copy_history      = get_bits(&s->gb, 2);
00754     s->source_pcm_res    = get_bits(&s->gb, 3);
00755     s->front_sum         = get_bits(&s->gb, 1);
00756     s->surround_sum      = get_bits(&s->gb, 1);
00757     s->dialog_norm       = get_bits(&s->gb, 4);
00758 
00759     /* FIXME: channels mixing levels */
00760     s->output = s->amode;
00761     if (s->lfe)
00762         s->output |= DCA_LFE;
00763 
00764 #ifdef TRACE
00765     av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
00766     av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
00767     av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
00768     av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
00769            s->sample_blocks, s->sample_blocks * 32);
00770     av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
00771     av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
00772            s->amode, dca_channels[s->amode]);
00773     av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
00774            s->sample_rate);
00775     av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
00776            s->bit_rate);
00777     av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
00778     av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
00779     av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
00780     av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
00781     av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
00782     av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
00783     av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
00784     av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
00785     av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
00786     av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
00787            s->predictor_history);
00788     av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
00789     av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
00790            s->multirate_inter);
00791     av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
00792     av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
00793     av_log(s->avctx, AV_LOG_DEBUG,
00794            "source pcm resolution: %i (%i bits/sample)\n",
00795            s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
00796     av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
00797     av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
00798     av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
00799     av_log(s->avctx, AV_LOG_DEBUG, "\n");
00800 #endif
00801 
00802     /* Primary audio coding header */
00803     s->subframes         = get_bits(&s->gb, 4) + 1;
00804 
00805     return dca_parse_audio_coding_header(s, 0, 0);
00806 }
00807 
00808 
00809 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
00810 {
00811     if (level < 5) {
00812         /* huffman encoded */
00813         value += get_bitalloc(gb, &dca_scalefactor, level);
00814         value = av_clip(value, 0, (1 << log2range) - 1);
00815     } else if (level < 8) {
00816         if (level + 1 > log2range) {
00817             skip_bits(gb, level + 1 - log2range);
00818             value = get_bits(gb, log2range);
00819         } else {
00820             value = get_bits(gb, level + 1);
00821         }
00822     }
00823     return value;
00824 }
00825 
00826 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
00827 {
00828     /* Primary audio coding side information */
00829     int j, k;
00830 
00831     if (get_bits_left(&s->gb) < 0)
00832         return AVERROR_INVALIDDATA;
00833 
00834     if (!base_channel) {
00835         s->subsubframes[s->current_subframe]    = get_bits(&s->gb, 2) + 1;
00836         s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
00837     }
00838 
00839     for (j = base_channel; j < s->prim_channels; j++) {
00840         for (k = 0; k < s->subband_activity[j]; k++)
00841             s->prediction_mode[j][k] = get_bits(&s->gb, 1);
00842     }
00843 
00844     /* Get prediction codebook */
00845     for (j = base_channel; j < s->prim_channels; j++) {
00846         for (k = 0; k < s->subband_activity[j]; k++) {
00847             if (s->prediction_mode[j][k] > 0) {
00848                 /* (Prediction coefficient VQ address) */
00849                 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00850             }
00851         }
00852     }
00853 
00854     /* Bit allocation index */
00855     for (j = base_channel; j < s->prim_channels; j++) {
00856         for (k = 0; k < s->vq_start_subband[j]; k++) {
00857             if (s->bitalloc_huffman[j] == 6)
00858                 s->bitalloc[j][k] = get_bits(&s->gb, 5);
00859             else if (s->bitalloc_huffman[j] == 5)
00860                 s->bitalloc[j][k] = get_bits(&s->gb, 4);
00861             else if (s->bitalloc_huffman[j] == 7) {
00862                 av_log(s->avctx, AV_LOG_ERROR,
00863                        "Invalid bit allocation index\n");
00864                 return AVERROR_INVALIDDATA;
00865             } else {
00866                 s->bitalloc[j][k] =
00867                     get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
00868             }
00869 
00870             if (s->bitalloc[j][k] > 26) {
00871                 av_dlog(s->avctx, "bitalloc index [%i][%i] too big (%i)\n",
00872                         j, k, s->bitalloc[j][k]);
00873                 return AVERROR_INVALIDDATA;
00874             }
00875         }
00876     }
00877 
00878     /* Transition mode */
00879     for (j = base_channel; j < s->prim_channels; j++) {
00880         for (k = 0; k < s->subband_activity[j]; k++) {
00881             s->transition_mode[j][k] = 0;
00882             if (s->subsubframes[s->current_subframe] > 1 &&
00883                 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
00884                 s->transition_mode[j][k] =
00885                     get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
00886             }
00887         }
00888     }
00889 
00890     if (get_bits_left(&s->gb) < 0)
00891         return AVERROR_INVALIDDATA;
00892 
00893     for (j = base_channel; j < s->prim_channels; j++) {
00894         const uint32_t *scale_table;
00895         int scale_sum, log_size;
00896 
00897         memset(s->scale_factor[j], 0,
00898                s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
00899 
00900         if (s->scalefactor_huffman[j] == 6) {
00901             scale_table = scale_factor_quant7;
00902             log_size = 7;
00903         } else {
00904             scale_table = scale_factor_quant6;
00905             log_size = 6;
00906         }
00907 
00908         /* When huffman coded, only the difference is encoded */
00909         scale_sum = 0;
00910 
00911         for (k = 0; k < s->subband_activity[j]; k++) {
00912             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
00913                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00914                 s->scale_factor[j][k][0] = scale_table[scale_sum];
00915             }
00916 
00917             if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
00918                 /* Get second scale factor */
00919                 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00920                 s->scale_factor[j][k][1] = scale_table[scale_sum];
00921             }
00922         }
00923     }
00924 
00925     /* Joint subband scale factor codebook select */
00926     for (j = base_channel; j < s->prim_channels; j++) {
00927         /* Transmitted only if joint subband coding enabled */
00928         if (s->joint_intensity[j] > 0)
00929             s->joint_huff[j] = get_bits(&s->gb, 3);
00930     }
00931 
00932     if (get_bits_left(&s->gb) < 0)
00933         return AVERROR_INVALIDDATA;
00934 
00935     /* Scale factors for joint subband coding */
00936     for (j = base_channel; j < s->prim_channels; j++) {
00937         int source_channel;
00938 
00939         /* Transmitted only if joint subband coding enabled */
00940         if (s->joint_intensity[j] > 0) {
00941             int scale = 0;
00942             source_channel = s->joint_intensity[j] - 1;
00943 
00944             /* When huffman coded, only the difference is encoded
00945              * (is this valid as well for joint scales ???) */
00946 
00947             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
00948                 scale = get_scale(&s->gb, s->joint_huff[j], 64 /* bias */, 7);
00949                 s->joint_scale_factor[j][k] = scale;    /*joint_scale_table[scale]; */
00950             }
00951 
00952             if (!(s->debug_flag & 0x02)) {
00953                 av_log(s->avctx, AV_LOG_DEBUG,
00954                        "Joint stereo coding not supported\n");
00955                 s->debug_flag |= 0x02;
00956             }
00957         }
00958     }
00959 
00960     /* Stereo downmix coefficients */
00961     if (!base_channel && s->prim_channels > 2) {
00962         if (s->downmix) {
00963             for (j = base_channel; j < s->prim_channels; j++) {
00964                 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
00965                 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
00966             }
00967         } else {
00968             int am = s->amode & DCA_CHANNEL_MASK;
00969             if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
00970                 av_log(s->avctx, AV_LOG_ERROR,
00971                        "Invalid channel mode %d\n", am);
00972                 return AVERROR_INVALIDDATA;
00973             }
00974             for (j = base_channel; j < FFMIN(s->prim_channels, FF_ARRAY_ELEMS(dca_default_coeffs[am])); j++) {
00975                 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
00976                 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
00977             }
00978         }
00979     }
00980 
00981     /* Dynamic range coefficient */
00982     if (!base_channel && s->dynrange)
00983         s->dynrange_coef = get_bits(&s->gb, 8);
00984 
00985     /* Side information CRC check word */
00986     if (s->crc_present) {
00987         get_bits(&s->gb, 16);
00988     }
00989 
00990     /*
00991      * Primary audio data arrays
00992      */
00993 
00994     /* VQ encoded high frequency subbands */
00995     for (j = base_channel; j < s->prim_channels; j++)
00996         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00997             /* 1 vector -> 32 samples */
00998             s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00999 
01000     /* Low frequency effect data */
01001     if (!base_channel && s->lfe) {
01002         int quant7;
01003         /* LFE samples */
01004         int lfe_samples = 2 * s->lfe * (4 + block_index);
01005         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
01006         float lfe_scale;
01007 
01008         for (j = lfe_samples; j < lfe_end_sample; j++) {
01009             /* Signed 8 bits int */
01010             s->lfe_data[j] = get_sbits(&s->gb, 8);
01011         }
01012 
01013         /* Scale factor index */
01014         quant7 = get_bits(&s->gb, 8);
01015         if (quant7 > 127) {
01016             av_log_ask_for_sample(s->avctx, "LFEScaleIndex larger than 127\n");
01017             return AVERROR_INVALIDDATA;
01018         }
01019         s->lfe_scale_factor = scale_factor_quant7[quant7];
01020 
01021         /* Quantization step size * scale factor */
01022         lfe_scale = 0.035 * s->lfe_scale_factor;
01023 
01024         for (j = lfe_samples; j < lfe_end_sample; j++)
01025             s->lfe_data[j] *= lfe_scale;
01026     }
01027 
01028 #ifdef TRACE
01029     av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
01030            s->subsubframes[s->current_subframe]);
01031     av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
01032            s->partial_samples[s->current_subframe]);
01033 
01034     for (j = base_channel; j < s->prim_channels; j++) {
01035         av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
01036         for (k = 0; k < s->subband_activity[j]; k++)
01037             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
01038         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01039     }
01040     for (j = base_channel; j < s->prim_channels; j++) {
01041         for (k = 0; k < s->subband_activity[j]; k++)
01042             av_log(s->avctx, AV_LOG_DEBUG,
01043                    "prediction coefs: %f, %f, %f, %f\n",
01044                    (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
01045                    (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
01046                    (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
01047                    (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
01048     }
01049     for (j = base_channel; j < s->prim_channels; j++) {
01050         av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
01051         for (k = 0; k < s->vq_start_subband[j]; k++)
01052             av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
01053         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01054     }
01055     for (j = base_channel; j < s->prim_channels; j++) {
01056         av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
01057         for (k = 0; k < s->subband_activity[j]; k++)
01058             av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
01059         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01060     }
01061     for (j = base_channel; j < s->prim_channels; j++) {
01062         av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
01063         for (k = 0; k < s->subband_activity[j]; k++) {
01064             if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
01065                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
01066             if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
01067                 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
01068         }
01069         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01070     }
01071     for (j = base_channel; j < s->prim_channels; j++) {
01072         if (s->joint_intensity[j] > 0) {
01073             int source_channel = s->joint_intensity[j] - 1;
01074             av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
01075             for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
01076                 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
01077             av_log(s->avctx, AV_LOG_DEBUG, "\n");
01078         }
01079     }
01080     if (!base_channel && s->prim_channels > 2 && s->downmix) {
01081         av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
01082         for (j = 0; j < s->prim_channels; j++) {
01083             av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
01084                    dca_downmix_coeffs[s->downmix_coef[j][0]]);
01085             av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
01086                    dca_downmix_coeffs[s->downmix_coef[j][1]]);
01087         }
01088         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01089     }
01090     for (j = base_channel; j < s->prim_channels; j++)
01091         for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
01092             av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
01093     if (!base_channel && s->lfe) {
01094         int lfe_samples = 2 * s->lfe * (4 + block_index);
01095         int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
01096 
01097         av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
01098         for (j = lfe_samples; j < lfe_end_sample; j++)
01099             av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
01100         av_log(s->avctx, AV_LOG_DEBUG, "\n");
01101     }
01102 #endif
01103 
01104     return 0;
01105 }
01106 
01107 static void qmf_32_subbands(DCAContext *s, int chans,
01108                             float samples_in[32][8], float *samples_out,
01109                             float scale)
01110 {
01111     const float *prCoeff;
01112     int i;
01113 
01114     int sb_act = s->subband_activity[chans];
01115     int subindex;
01116 
01117     scale *= sqrt(1 / 8.0);
01118 
01119     /* Select filter */
01120     if (!s->multirate_inter)    /* Non-perfect reconstruction */
01121         prCoeff = fir_32bands_nonperfect;
01122     else                        /* Perfect reconstruction */
01123         prCoeff = fir_32bands_perfect;
01124 
01125     for (i = sb_act; i < 32; i++)
01126         s->raXin[i] = 0.0;
01127 
01128     /* Reconstructed channel sample index */
01129     for (subindex = 0; subindex < 8; subindex++) {
01130         /* Load in one sample from each subband and clear inactive subbands */
01131         for (i = 0; i < sb_act; i++) {
01132             unsigned sign = (i - 1) & 2;
01133             uint32_t v    = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
01134             AV_WN32A(&s->raXin[i], v);
01135         }
01136 
01137         s->synth.synth_filter_float(&s->imdct,
01138                                     s->subband_fir_hist[chans],
01139                                     &s->hist_index[chans],
01140                                     s->subband_fir_noidea[chans], prCoeff,
01141                                     samples_out, s->raXin, scale);
01142         samples_out += 32;
01143     }
01144 }
01145 
01146 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
01147                                   int num_deci_sample, float *samples_in,
01148                                   float *samples_out, float scale)
01149 {
01150     /* samples_in: An array holding decimated samples.
01151      *   Samples in current subframe starts from samples_in[0],
01152      *   while samples_in[-1], samples_in[-2], ..., stores samples
01153      *   from last subframe as history.
01154      *
01155      * samples_out: An array holding interpolated samples
01156      */
01157 
01158     int decifactor;
01159     const float *prCoeff;
01160     int deciindex;
01161 
01162     /* Select decimation filter */
01163     if (decimation_select == 1) {
01164         decifactor = 64;
01165         prCoeff = lfe_fir_128;
01166     } else {
01167         decifactor = 32;
01168         prCoeff = lfe_fir_64;
01169     }
01170     /* Interpolation */
01171     for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
01172         s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
01173         samples_in++;
01174         samples_out += 2 * decifactor;
01175     }
01176 }
01177 
01178 /* downmixing routines */
01179 #define MIX_REAR1(samples, s1, rs, coef)            \
01180     samples[0][i] += samples[s1][i] * coef[rs][0];  \
01181     samples[1][i] += samples[s1][i] * coef[rs][1];
01182 
01183 #define MIX_REAR2(samples, s1, s2, rs, coef)                                          \
01184     samples[0][i] += samples[s1][i] * coef[rs][0] + samples[s2][i] * coef[rs + 1][0]; \
01185     samples[1][i] += samples[s1][i] * coef[rs][1] + samples[s2][i] * coef[rs + 1][1];
01186 
01187 #define MIX_FRONT3(samples, coef)                                      \
01188     t = samples[c][i];                                                 \
01189     u = samples[l][i];                                                 \
01190     v = samples[r][i];                                                 \
01191     samples[0][i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0];  \
01192     samples[1][i] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
01193 
01194 #define DOWNMIX_TO_STEREO(op1, op2)             \
01195     for (i = 0; i < 256; i++) {                 \
01196         op1                                     \
01197         op2                                     \
01198     }
01199 
01200 static void dca_downmix(float **samples, int srcfmt,
01201                         int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
01202                         const int8_t *channel_mapping)
01203 {
01204     int c, l, r, sl, sr, s;
01205     int i;
01206     float t, u, v;
01207     float coef[DCA_PRIM_CHANNELS_MAX][2];
01208 
01209     for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
01210         coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
01211         coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
01212     }
01213 
01214     switch (srcfmt) {
01215     case DCA_MONO:
01216     case DCA_CHANNEL:
01217     case DCA_STEREO_TOTAL:
01218     case DCA_STEREO_SUMDIFF:
01219     case DCA_4F2R:
01220         av_log(NULL, AV_LOG_ERROR, "Not implemented!\n");
01221         break;
01222     case DCA_STEREO:
01223         break;
01224     case DCA_3F:
01225         c = channel_mapping[0];
01226         l = channel_mapping[1];
01227         r = channel_mapping[2];
01228         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
01229         break;
01230     case DCA_2F1R:
01231         s = channel_mapping[2];
01232         DOWNMIX_TO_STEREO(MIX_REAR1(samples, s, 2, coef), );
01233         break;
01234     case DCA_3F1R:
01235         c = channel_mapping[0];
01236         l = channel_mapping[1];
01237         r = channel_mapping[2];
01238         s = channel_mapping[3];
01239         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01240                           MIX_REAR1(samples, s, 3, coef));
01241         break;
01242     case DCA_2F2R:
01243         sl = channel_mapping[2];
01244         sr = channel_mapping[3];
01245         DOWNMIX_TO_STEREO(MIX_REAR2(samples, sl, sr, 2, coef), );
01246         break;
01247     case DCA_3F2R:
01248         c  = channel_mapping[0];
01249         l  = channel_mapping[1];
01250         r  = channel_mapping[2];
01251         sl = channel_mapping[3];
01252         sr = channel_mapping[4];
01253         DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01254                           MIX_REAR2(samples, sl, sr, 3, coef));
01255         break;
01256     }
01257 }
01258 
01259 
01260 #ifndef decode_blockcodes
01261 /* Very compact version of the block code decoder that does not use table
01262  * look-up but is slightly slower */
01263 static int decode_blockcode(int code, int levels, int *values)
01264 {
01265     int i;
01266     int offset = (levels - 1) >> 1;
01267 
01268     for (i = 0; i < 4; i++) {
01269         int div = FASTDIV(code, levels);
01270         values[i] = code - offset - div * levels;
01271         code = div;
01272     }
01273 
01274     return code;
01275 }
01276 
01277 static int decode_blockcodes(int code1, int code2, int levels, int *values)
01278 {
01279     return decode_blockcode(code1, levels, values) |
01280            decode_blockcode(code2, levels, values + 4);
01281 }
01282 #endif
01283 
01284 static const uint8_t abits_sizes[7]  = { 7, 10, 12, 13, 15, 17, 19 };
01285 static const uint8_t abits_levels[7] = { 3,  5,  7,  9, 13, 17, 25 };
01286 
01287 #ifndef int8x8_fmul_int32
01288 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
01289 {
01290     float fscale = scale / 16.0;
01291     int i;
01292     for (i = 0; i < 8; i++)
01293         dst[i] = src[i] * fscale;
01294 }
01295 #endif
01296 
01297 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
01298 {
01299     int k, l;
01300     int subsubframe = s->current_subsubframe;
01301 
01302     const float *quant_step_table;
01303 
01304     /* FIXME */
01305     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01306     LOCAL_ALIGNED_16(int, block, [8]);
01307 
01308     /*
01309      * Audio data
01310      */
01311 
01312     /* Select quantization step size table */
01313     if (s->bit_rate_index == 0x1f)
01314         quant_step_table = lossless_quant_d;
01315     else
01316         quant_step_table = lossy_quant_d;
01317 
01318     for (k = base_channel; k < s->prim_channels; k++) {
01319         if (get_bits_left(&s->gb) < 0)
01320             return AVERROR_INVALIDDATA;
01321 
01322         for (l = 0; l < s->vq_start_subband[k]; l++) {
01323             int m;
01324 
01325             /* Select the mid-tread linear quantizer */
01326             int abits = s->bitalloc[k][l];
01327 
01328             float quant_step_size = quant_step_table[abits];
01329 
01330             /*
01331              * Determine quantization index code book and its type
01332              */
01333 
01334             /* Select quantization index code book */
01335             int sel = s->quant_index_huffman[k][abits];
01336 
01337             /*
01338              * Extract bits from the bit stream
01339              */
01340             if (!abits) {
01341                 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
01342             } else {
01343                 /* Deal with transients */
01344                 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
01345                 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
01346                                s->scalefactor_adj[k][sel];
01347 
01348                 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
01349                     if (abits <= 7) {
01350                         /* Block code */
01351                         int block_code1, block_code2, size, levels, err;
01352 
01353                         size   = abits_sizes[abits - 1];
01354                         levels = abits_levels[abits - 1];
01355 
01356                         block_code1 = get_bits(&s->gb, size);
01357                         block_code2 = get_bits(&s->gb, size);
01358                         err = decode_blockcodes(block_code1, block_code2,
01359                                                 levels, block);
01360                         if (err) {
01361                             av_log(s->avctx, AV_LOG_ERROR,
01362                                    "ERROR: block code look-up failed\n");
01363                             return AVERROR_INVALIDDATA;
01364                         }
01365                     } else {
01366                         /* no coding */
01367                         for (m = 0; m < 8; m++)
01368                             block[m] = get_sbits(&s->gb, abits - 3);
01369                     }
01370                 } else {
01371                     /* Huffman coded */
01372                     for (m = 0; m < 8; m++)
01373                         block[m] = get_bitalloc(&s->gb,
01374                                                 &dca_smpl_bitalloc[abits], sel);
01375                 }
01376 
01377                 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
01378                                                        block, rscale, 8);
01379             }
01380 
01381             /*
01382              * Inverse ADPCM if in prediction mode
01383              */
01384             if (s->prediction_mode[k][l]) {
01385                 int n;
01386                 for (m = 0; m < 8; m++) {
01387                     for (n = 1; n <= 4; n++)
01388                         if (m >= n)
01389                             subband_samples[k][l][m] +=
01390                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01391                                  subband_samples[k][l][m - n] / 8192);
01392                         else if (s->predictor_history)
01393                             subband_samples[k][l][m] +=
01394                                 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01395                                  s->subband_samples_hist[k][l][m - n + 4] / 8192);
01396                 }
01397             }
01398         }
01399 
01400         /*
01401          * Decode VQ encoded high frequencies
01402          */
01403         for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01404             /* 1 vector -> 32 samples but we only need the 8 samples
01405              * for this subsubframe. */
01406             int hfvq = s->high_freq_vq[k][l];
01407 
01408             if (!s->debug_flag & 0x01) {
01409                 av_log(s->avctx, AV_LOG_DEBUG,
01410                        "Stream with high frequencies VQ coding\n");
01411                 s->debug_flag |= 0x01;
01412             }
01413 
01414             int8x8_fmul_int32(subband_samples[k][l],
01415                               &high_freq_vq[hfvq][subsubframe * 8],
01416                               s->scale_factor[k][l][0]);
01417         }
01418     }
01419 
01420     /* Check for DSYNC after subsubframe */
01421     if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
01422         if (0xFFFF == get_bits(&s->gb, 16)) {   /* 0xFFFF */
01423 #ifdef TRACE
01424             av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
01425 #endif
01426         } else {
01427             av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
01428         }
01429     }
01430 
01431     /* Backup predictor history for adpcm */
01432     for (k = base_channel; k < s->prim_channels; k++)
01433         for (l = 0; l < s->vq_start_subband[k]; l++)
01434             memcpy(s->subband_samples_hist[k][l],
01435                    &subband_samples[k][l][4],
01436                    4 * sizeof(subband_samples[0][0][0]));
01437 
01438     return 0;
01439 }
01440 
01441 static int dca_filter_channels(DCAContext *s, int block_index)
01442 {
01443     float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01444     int k;
01445 
01446     /* 32 subbands QMF */
01447     for (k = 0; k < s->prim_channels; k++) {
01448 /*        static float pcm_to_double[8] = { 32768.0, 32768.0, 524288.0, 524288.0,
01449                                             0, 8388608.0, 8388608.0 };*/
01450         if (s->channel_order_tab[k] >= 0)
01451             qmf_32_subbands(s, k, subband_samples[k],
01452                             s->samples_chanptr[s->channel_order_tab[k]],
01453                             M_SQRT1_2 / 32768.0 /* pcm_to_double[s->source_pcm_res] */);
01454     }
01455 
01456     /* Down mixing */
01457     if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
01458         dca_downmix(s->samples_chanptr, s->amode, s->downmix_coef, s->channel_order_tab);
01459     }
01460 
01461     /* Generate LFE samples for this subsubframe FIXME!!! */
01462     if (s->output & DCA_LFE) {
01463         lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
01464                               s->lfe_data + 2 * s->lfe * (block_index + 4),
01465                               s->samples_chanptr[s->lfe_index],
01466                               1.0 / (256.0 * 32768.0));
01467         /* Outputs 20bits pcm samples */
01468     }
01469 
01470     return 0;
01471 }
01472 
01473 
01474 static int dca_subframe_footer(DCAContext *s, int base_channel)
01475 {
01476     int aux_data_count = 0, i;
01477 
01478     /*
01479      * Unpack optional information
01480      */
01481 
01482     /* presumably optional information only appears in the core? */
01483     if (!base_channel) {
01484         if (s->timestamp)
01485             skip_bits_long(&s->gb, 32);
01486 
01487         if (s->aux_data)
01488             aux_data_count = get_bits(&s->gb, 6);
01489 
01490         for (i = 0; i < aux_data_count; i++)
01491             get_bits(&s->gb, 8);
01492 
01493         if (s->crc_present && (s->downmix || s->dynrange))
01494             get_bits(&s->gb, 16);
01495     }
01496 
01497     return 0;
01498 }
01499 
01506 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
01507 {
01508     int ret;
01509 
01510     /* Sanity check */
01511     if (s->current_subframe >= s->subframes) {
01512         av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
01513                s->current_subframe, s->subframes);
01514         return AVERROR_INVALIDDATA;
01515     }
01516 
01517     if (!s->current_subsubframe) {
01518 #ifdef TRACE
01519         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
01520 #endif
01521         /* Read subframe header */
01522         if ((ret = dca_subframe_header(s, base_channel, block_index)))
01523             return ret;
01524     }
01525 
01526     /* Read subsubframe */
01527 #ifdef TRACE
01528     av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
01529 #endif
01530     if ((ret = dca_subsubframe(s, base_channel, block_index)))
01531         return ret;
01532 
01533     /* Update state */
01534     s->current_subsubframe++;
01535     if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
01536         s->current_subsubframe = 0;
01537         s->current_subframe++;
01538     }
01539     if (s->current_subframe >= s->subframes) {
01540 #ifdef TRACE
01541         av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
01542 #endif
01543         /* Read subframe footer */
01544         if ((ret = dca_subframe_footer(s, base_channel)))
01545             return ret;
01546     }
01547 
01548     return 0;
01549 }
01550 
01554 static int dca_exss_mask2count(int mask)
01555 {
01556     /* count bits that mean speaker pairs twice */
01557     return av_popcount(mask) +
01558            av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT      |
01559                                DCA_EXSS_FRONT_LEFT_RIGHT       |
01560                                DCA_EXSS_FRONT_HIGH_LEFT_RIGHT  |
01561                                DCA_EXSS_WIDE_LEFT_RIGHT        |
01562                                DCA_EXSS_SIDE_LEFT_RIGHT        |
01563                                DCA_EXSS_SIDE_HIGH_LEFT_RIGHT   |
01564                                DCA_EXSS_SIDE_REAR_LEFT_RIGHT   |
01565                                DCA_EXSS_REAR_LEFT_RIGHT        |
01566                                DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
01567 }
01568 
01572 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
01573 {
01574     int i;
01575 
01576     for (i = 0; i < channels; i++) {
01577         int mix_map_mask = get_bits(gb, out_ch);
01578         int num_coeffs = av_popcount(mix_map_mask);
01579         skip_bits_long(gb, num_coeffs * 6);
01580     }
01581 }
01582 
01586 static int dca_exss_parse_asset_header(DCAContext *s)
01587 {
01588     int header_pos = get_bits_count(&s->gb);
01589     int header_size;
01590     int channels = 0;
01591     int embedded_stereo = 0;
01592     int embedded_6ch    = 0;
01593     int drc_code_present;
01594     int av_uninit(extensions_mask);
01595     int i, j;
01596 
01597     if (get_bits_left(&s->gb) < 16)
01598         return -1;
01599 
01600     /* We will parse just enough to get to the extensions bitmask with which
01601      * we can set the profile value. */
01602 
01603     header_size = get_bits(&s->gb, 9) + 1;
01604     skip_bits(&s->gb, 3); // asset index
01605 
01606     if (s->static_fields) {
01607         if (get_bits1(&s->gb))
01608             skip_bits(&s->gb, 4); // asset type descriptor
01609         if (get_bits1(&s->gb))
01610             skip_bits_long(&s->gb, 24); // language descriptor
01611 
01612         if (get_bits1(&s->gb)) {
01613             /* How can one fit 1024 bytes of text here if the maximum value
01614              * for the asset header size field above was 512 bytes? */
01615             int text_length = get_bits(&s->gb, 10) + 1;
01616             if (get_bits_left(&s->gb) < text_length * 8)
01617                 return -1;
01618             skip_bits_long(&s->gb, text_length * 8); // info text
01619         }
01620 
01621         skip_bits(&s->gb, 5); // bit resolution - 1
01622         skip_bits(&s->gb, 4); // max sample rate code
01623         channels = get_bits(&s->gb, 8) + 1;
01624 
01625         if (get_bits1(&s->gb)) { // 1-to-1 channels to speakers
01626             int spkr_remap_sets;
01627             int spkr_mask_size = 16;
01628             int num_spkrs[7];
01629 
01630             if (channels > 2)
01631                 embedded_stereo = get_bits1(&s->gb);
01632             if (channels > 6)
01633                 embedded_6ch = get_bits1(&s->gb);
01634 
01635             if (get_bits1(&s->gb)) {
01636                 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
01637                 skip_bits(&s->gb, spkr_mask_size); // spkr activity mask
01638             }
01639 
01640             spkr_remap_sets = get_bits(&s->gb, 3);
01641 
01642             for (i = 0; i < spkr_remap_sets; i++) {
01643                 /* std layout mask for each remap set */
01644                 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
01645             }
01646 
01647             for (i = 0; i < spkr_remap_sets; i++) {
01648                 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
01649                 if (get_bits_left(&s->gb) < 0)
01650                     return -1;
01651 
01652                 for (j = 0; j < num_spkrs[i]; j++) {
01653                     int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
01654                     int num_dec_ch = av_popcount(remap_dec_ch_mask);
01655                     skip_bits_long(&s->gb, num_dec_ch * 5); // remap codes
01656                 }
01657             }
01658 
01659         } else {
01660             skip_bits(&s->gb, 3); // representation type
01661         }
01662     }
01663 
01664     drc_code_present = get_bits1(&s->gb);
01665     if (drc_code_present)
01666         get_bits(&s->gb, 8); // drc code
01667 
01668     if (get_bits1(&s->gb))
01669         skip_bits(&s->gb, 5); // dialog normalization code
01670 
01671     if (drc_code_present && embedded_stereo)
01672         get_bits(&s->gb, 8); // drc stereo code
01673 
01674     if (s->mix_metadata && get_bits1(&s->gb)) {
01675         skip_bits(&s->gb, 1); // external mix
01676         skip_bits(&s->gb, 6); // post mix gain code
01677 
01678         if (get_bits(&s->gb, 2) != 3) // mixer drc code
01679             skip_bits(&s->gb, 3); // drc limit
01680         else
01681             skip_bits(&s->gb, 8); // custom drc code
01682 
01683         if (get_bits1(&s->gb)) // channel specific scaling
01684             for (i = 0; i < s->num_mix_configs; i++)
01685                 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6); // scale codes
01686         else
01687             skip_bits_long(&s->gb, s->num_mix_configs * 6); // scale codes
01688 
01689         for (i = 0; i < s->num_mix_configs; i++) {
01690             if (get_bits_left(&s->gb) < 0)
01691                 return -1;
01692             dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
01693             if (embedded_6ch)
01694                 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
01695             if (embedded_stereo)
01696                 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
01697         }
01698     }
01699 
01700     switch (get_bits(&s->gb, 2)) {
01701     case 0: extensions_mask = get_bits(&s->gb, 12); break;
01702     case 1: extensions_mask = DCA_EXT_EXSS_XLL;     break;
01703     case 2: extensions_mask = DCA_EXT_EXSS_LBR;     break;
01704     case 3: extensions_mask = 0; /* aux coding */   break;
01705     }
01706 
01707     /* not parsed further, we were only interested in the extensions mask */
01708 
01709     if (get_bits_left(&s->gb) < 0)
01710         return -1;
01711 
01712     if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
01713         av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
01714         return -1;
01715     }
01716     skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
01717 
01718     if (extensions_mask & DCA_EXT_EXSS_XLL)
01719         s->profile = FF_PROFILE_DTS_HD_MA;
01720     else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
01721                                 DCA_EXT_EXSS_XXCH))
01722         s->profile = FF_PROFILE_DTS_HD_HRA;
01723 
01724     if (!(extensions_mask & DCA_EXT_CORE))
01725         av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
01726     if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
01727         av_log(s->avctx, AV_LOG_WARNING,
01728                "DTS extensions detection mismatch (%d, %d)\n",
01729                extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
01730 
01731     return 0;
01732 }
01733 
01734 static int dca_xbr_parse_frame(DCAContext *s)
01735 {
01736     int scale_table_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS][2];
01737     int active_bands[DCA_CHSETS_MAX][DCA_CHSET_CHANS_MAX];
01738     int abits_high[DCA_CHSET_CHANS_MAX][DCA_SUBBANDS];
01739     int anctemp[DCA_CHSET_CHANS_MAX];
01740     int chset_fsize[DCA_CHSETS_MAX];
01741     int n_xbr_ch[DCA_CHSETS_MAX];
01742     int hdr_size, num_chsets, xbr_tmode, hdr_pos;
01743     int i, j, k, l, chset, chan_base;
01744 
01745     av_log(s->avctx, AV_LOG_DEBUG, "DTS-XBR: decoding XBR extension\n");
01746 
01747     /* get bit position of sync header */
01748     hdr_pos = get_bits_count(&s->gb) - 32;
01749 
01750     hdr_size = get_bits(&s->gb, 6) + 1;
01751     num_chsets = get_bits(&s->gb, 2) + 1;
01752 
01753     for(i = 0; i < num_chsets; i++)
01754         chset_fsize[i] = get_bits(&s->gb, 14) + 1;
01755 
01756     xbr_tmode = get_bits1(&s->gb);
01757 
01758     for(i = 0; i < num_chsets; i++) {
01759         n_xbr_ch[i] = get_bits(&s->gb, 3) + 1;
01760         k = get_bits(&s->gb, 2) + 5;
01761         for(j = 0; j < n_xbr_ch[i]; j++)
01762             active_bands[i][j] = get_bits(&s->gb, k) + 1;
01763     }
01764 
01765     /* skip to the end of the header */
01766     i = get_bits_count(&s->gb);
01767     if(hdr_pos + hdr_size * 8 > i)
01768         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
01769 
01770     /* loop over the channel data sets */
01771     /* only decode as many channels as we've decoded base data for */
01772     for(chset = 0, chan_base = 0;
01773         chset < num_chsets && chan_base + n_xbr_ch[chset] <= s->prim_channels;
01774         chan_base += n_xbr_ch[chset++]) {
01775         int start_posn = get_bits_count(&s->gb);
01776         int subsubframe = 0;
01777         int subframe = 0;
01778 
01779         /* loop over subframes */
01780         for (k = 0; k < (s->sample_blocks / 8); k++) {
01781             /* parse header if we're on first subsubframe of a block */
01782             if(subsubframe == 0) {
01783                 /* Parse subframe header */
01784                 for(i = 0; i < n_xbr_ch[chset]; i++) {
01785                     anctemp[i] = get_bits(&s->gb, 2) + 2;
01786                 }
01787 
01788                 for(i = 0; i < n_xbr_ch[chset]; i++) {
01789                     get_array(&s->gb, abits_high[i], active_bands[chset][i], anctemp[i]);
01790                 }
01791 
01792                 for(i = 0; i < n_xbr_ch[chset]; i++) {
01793                     anctemp[i] = get_bits(&s->gb, 3);
01794                     if(anctemp[i] < 1) {
01795                         av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: SYNC ERROR\n");
01796                         return AVERROR_INVALIDDATA;
01797                     }
01798                 }
01799 
01800                 /* generate scale factors */
01801                 for(i = 0; i < n_xbr_ch[chset]; i++) {
01802                     const uint32_t *scale_table;
01803                     int nbits;
01804 
01805                     if (s->scalefactor_huffman[chan_base+i] == 6) {
01806                         scale_table = scale_factor_quant7;
01807                     } else {
01808                         scale_table = scale_factor_quant6;
01809                     }
01810 
01811                     nbits = anctemp[i];
01812 
01813                     for(j = 0; j < active_bands[chset][i]; j++) {
01814                         if(abits_high[i][j] > 0) {
01815                             scale_table_high[i][j][0] =
01816                                 scale_table[get_bits(&s->gb, nbits)];
01817 
01818                             if(xbr_tmode && s->transition_mode[i][j]) {
01819                                 scale_table_high[i][j][1] =
01820                                     scale_table[get_bits(&s->gb, nbits)];
01821                             }
01822                         }
01823                     }
01824                 }
01825             }
01826 
01827             /* decode audio array for this block */
01828             for(i = 0; i < n_xbr_ch[chset]; i++) {
01829                 for(j = 0; j < active_bands[chset][i]; j++) {
01830                     const int xbr_abits = abits_high[i][j];
01831                     const float quant_step_size = lossless_quant_d[xbr_abits];
01832                     const int sfi = xbr_tmode && s->transition_mode[i][j] && subsubframe >= s->transition_mode[i][j];
01833                     const float rscale = quant_step_size * scale_table_high[i][j][sfi];
01834                     float *subband_samples = s->subband_samples[k][chan_base+i][j];
01835                     int block[8];
01836 
01837                     if(xbr_abits <= 0)
01838                         continue;
01839 
01840                     if(xbr_abits > 7) {
01841                         get_array(&s->gb, block, 8, xbr_abits - 3);
01842                     } else {
01843                         int block_code1, block_code2, size, levels, err;
01844 
01845                         size   = abits_sizes[xbr_abits - 1];
01846                         levels = abits_levels[xbr_abits - 1];
01847 
01848                         block_code1 = get_bits(&s->gb, size);
01849                         block_code2 = get_bits(&s->gb, size);
01850                         err = decode_blockcodes(block_code1, block_code2,
01851                                                 levels, block);
01852                         if (err) {
01853                             av_log(s->avctx, AV_LOG_ERROR,
01854                                    "ERROR: DTS-XBR: block code look-up failed\n");
01855                             return AVERROR_INVALIDDATA;
01856                         }
01857                     }
01858 
01859                     /* scale & sum into subband */
01860                     for(l = 0; l < 8; l++)
01861                         subband_samples[l] += (float)block[l] * rscale;
01862                 }
01863             }
01864 
01865             /* check DSYNC marker */
01866             if(s->aspf || subsubframe == s->subsubframes[subframe] - 1) {
01867                 if(get_bits(&s->gb, 16) != 0xffff) {
01868                     av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: Didn't get subframe DSYNC\n");
01869                     return AVERROR_INVALIDDATA;
01870                 }
01871             }
01872 
01873             /* advance sub-sub-frame index */
01874             if(++subsubframe >= s->subsubframes[subframe]) {
01875                 subsubframe = 0;
01876                 subframe++;
01877             }
01878         }
01879 
01880         /* skip to next channel set */
01881         i = get_bits_count(&s->gb);
01882         if(start_posn + chset_fsize[chset] * 8 != i) {
01883             j = start_posn + chset_fsize[chset] * 8 - i;
01884             if(j < 0 || j >= 8)
01885                 av_log(s->avctx, AV_LOG_ERROR, "DTS-XBR: end of channel set,"
01886                        " skipping further than expected (%d bits)\n", j);
01887             skip_bits_long(&s->gb, j);
01888         }
01889     }
01890 
01891     return 0;
01892 }
01893 
01894 /* parse initial header for XXCH and dump details */
01895 static int dca_xxch_decode_frame(DCAContext *s)
01896 {
01897     int hdr_size, spkmsk_bits, num_chsets, core_spk, hdr_pos;
01898     int i, chset, base_channel, chstart, fsize[8];
01899 
01900     /* assume header word has already been parsed */
01901     hdr_pos     = get_bits_count(&s->gb) - 32;
01902     hdr_size    = get_bits(&s->gb, 6) + 1;
01903   /*chhdr_crc   =*/ skip_bits1(&s->gb);
01904     spkmsk_bits = get_bits(&s->gb, 5) + 1;
01905     num_chsets  = get_bits(&s->gb, 2) + 1;
01906 
01907     for (i = 0; i < num_chsets; i++)
01908         fsize[i] = get_bits(&s->gb, 14) + 1;
01909 
01910     core_spk               = get_bits(&s->gb, spkmsk_bits);
01911     s->xxch_core_spkmask   = core_spk;
01912     s->xxch_nbits_spk_mask = spkmsk_bits;
01913     s->xxch_dmix_embedded  = 0;
01914 
01915     /* skip to the end of the header */
01916     i = get_bits_count(&s->gb);
01917     if (hdr_pos + hdr_size * 8 > i)
01918         skip_bits_long(&s->gb, hdr_pos + hdr_size * 8 - i);
01919 
01920     for (chset = 0; chset < num_chsets; chset++) {
01921         chstart       = get_bits_count(&s->gb);
01922         base_channel  = s->prim_channels;
01923         s->xxch_chset = chset;
01924 
01925         /* XXCH and Core headers differ, see 6.4.2 "XXCH Channel Set Header" vs.
01926            5.3.2 "Primary Audio Coding Header", DTS Spec 1.3.1 */
01927         dca_parse_audio_coding_header(s, base_channel, 1);
01928 
01929         /* decode channel data */
01930         for (i = 0; i < (s->sample_blocks / 8); i++) {
01931             if (dca_decode_block(s, base_channel, i)) {
01932                 av_log(s->avctx, AV_LOG_ERROR,
01933                        "Error decoding DTS-XXCH extension\n");
01934                 continue;
01935             }
01936         }
01937 
01938         /* skip to end of this section */
01939         i = get_bits_count(&s->gb);
01940         if (chstart + fsize[chset] * 8 > i)
01941             skip_bits_long(&s->gb, chstart + fsize[chset] * 8 - i);
01942     }
01943     s->xxch_chset = num_chsets;
01944 
01945     return 0;
01946 }
01947 
01951 static void dca_exss_parse_header(DCAContext *s)
01952 {
01953     int asset_size[8];
01954     int ss_index;
01955     int blownup;
01956     int num_audiop = 1;
01957     int num_assets = 1;
01958     int active_ss_mask[8];
01959     int i, j;
01960     int start_posn;
01961     int hdrsize;
01962     uint32_t mkr;
01963 
01964     if (get_bits_left(&s->gb) < 52)
01965         return;
01966 
01967     start_posn = get_bits_count(&s->gb) - 32;
01968 
01969     skip_bits(&s->gb, 8); // user data
01970     ss_index = get_bits(&s->gb, 2);
01971 
01972     blownup = get_bits1(&s->gb);
01973     hdrsize = get_bits(&s->gb,  8 + 4 * blownup) + 1; // header_size
01974     skip_bits(&s->gb, 16 + 4 * blownup); // hd_size
01975 
01976     s->static_fields = get_bits1(&s->gb);
01977     if (s->static_fields) {
01978         skip_bits(&s->gb, 2); // reference clock code
01979         skip_bits(&s->gb, 3); // frame duration code
01980 
01981         if (get_bits1(&s->gb))
01982             skip_bits_long(&s->gb, 36); // timestamp
01983 
01984         /* a single stream can contain multiple audio assets that can be
01985          * combined to form multiple audio presentations */
01986 
01987         num_audiop = get_bits(&s->gb, 3) + 1;
01988         if (num_audiop > 1) {
01989             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
01990             /* ignore such streams for now */
01991             return;
01992         }
01993 
01994         num_assets = get_bits(&s->gb, 3) + 1;
01995         if (num_assets > 1) {
01996             av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
01997             /* ignore such streams for now */
01998             return;
01999         }
02000 
02001         for (i = 0; i < num_audiop; i++)
02002             active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
02003 
02004         for (i = 0; i < num_audiop; i++)
02005             for (j = 0; j <= ss_index; j++)
02006                 if (active_ss_mask[i] & (1 << j))
02007                     skip_bits(&s->gb, 8); // active asset mask
02008 
02009         s->mix_metadata = get_bits1(&s->gb);
02010         if (s->mix_metadata) {
02011             int mix_out_mask_size;
02012 
02013             skip_bits(&s->gb, 2); // adjustment level
02014             mix_out_mask_size  = (get_bits(&s->gb, 2) + 1) << 2;
02015             s->num_mix_configs =  get_bits(&s->gb, 2) + 1;
02016 
02017             for (i = 0; i < s->num_mix_configs; i++) {
02018                 int mix_out_mask        = get_bits(&s->gb, mix_out_mask_size);
02019                 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
02020             }
02021         }
02022     }
02023 
02024     for (i = 0; i < num_assets; i++)
02025         asset_size[i] = get_bits_long(&s->gb, 16 + 4 * blownup);
02026 
02027     for (i = 0; i < num_assets; i++) {
02028         if (dca_exss_parse_asset_header(s))
02029             return;
02030     }
02031 
02032     /* not parsed further, we were only interested in the extensions mask
02033      * from the asset header */
02034 
02035     if (num_assets > 0) {
02036         j = get_bits_count(&s->gb);
02037         if (start_posn + hdrsize * 8 > j)
02038             skip_bits_long(&s->gb, start_posn + hdrsize * 8 - j);
02039 
02040         for (i = 0; i < num_assets; i++) {
02041             start_posn = get_bits_count(&s->gb);
02042             mkr        = get_bits_long(&s->gb, 32);
02043 
02044             /* parse extensions that we know about */
02045             if (mkr == 0x655e315e) {
02046                 dca_xbr_parse_frame(s);
02047             } else if (mkr == 0x47004a03) {
02048                 dca_xxch_decode_frame(s);
02049                 s->core_ext_mask |= DCA_EXT_XXCH; /* xxx use for chan reordering */
02050             } else {
02051                 av_log(s->avctx, AV_LOG_DEBUG,
02052                        "DTS-ExSS: unknown marker = 0x%08x\n", mkr);
02053             }
02054 
02055             /* skip to end of block */
02056             j = get_bits_count(&s->gb);
02057             if (start_posn + asset_size[i] * 8 > j)
02058                 skip_bits_long(&s->gb, start_posn + asset_size[i] * 8 - j);
02059         }
02060     }
02061 }
02062 
02067 static int dca_decode_frame(AVCodecContext *avctx, void *data,
02068                             int *got_frame_ptr, AVPacket *avpkt)
02069 {
02070     const uint8_t *buf = avpkt->data;
02071     int buf_size = avpkt->size;
02072     int channel_mask;
02073     int channel_layout;
02074     int lfe_samples;
02075     int num_core_channels = 0;
02076     int i, ret;
02077     float **samples_flt;
02078     float *src_chan;
02079     float *dst_chan;
02080     DCAContext *s = avctx->priv_data;
02081     int core_ss_end;
02082     int channels, full_channels;
02083     float scale;
02084     int achan;
02085     int chset;
02086     int mask;
02087     int lavc;
02088     int posn;
02089     int j, k;
02090     int endch;
02091 
02092     s->xch_present = 0;
02093 
02094     s->dca_buffer_size = ff_dca_convert_bitstream(buf, buf_size, s->dca_buffer,
02095                                                   DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
02096     if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
02097         av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
02098         return AVERROR_INVALIDDATA;
02099     }
02100 
02101     init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
02102     if ((ret = dca_parse_frame_header(s)) < 0) {
02103         //seems like the frame is corrupt, try with the next one
02104         return ret;
02105     }
02106     //set AVCodec values with parsed data
02107     avctx->sample_rate = s->sample_rate;
02108     avctx->bit_rate    = s->bit_rate;
02109 
02110     s->profile = FF_PROFILE_DTS;
02111 
02112     for (i = 0; i < (s->sample_blocks / 8); i++) {
02113         if ((ret = dca_decode_block(s, 0, i))) {
02114             av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
02115             return ret;
02116         }
02117     }
02118 
02119     /* record number of core channels incase less than max channels are requested */
02120     num_core_channels = s->prim_channels;
02121 
02122     if (s->ext_coding)
02123         s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
02124     else
02125         s->core_ext_mask = 0;
02126 
02127     core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
02128 
02129     /* only scan for extensions if ext_descr was unknown or indicated a
02130      * supported XCh extension */
02131     if (s->core_ext_mask < 0 || s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH)) {
02132 
02133         /* if ext_descr was unknown, clear s->core_ext_mask so that the
02134          * extensions scan can fill it up */
02135         s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
02136 
02137         /* extensions start at 32-bit boundaries into bitstream */
02138         skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
02139 
02140         while (core_ss_end - get_bits_count(&s->gb) >= 32) {
02141             uint32_t bits = get_bits_long(&s->gb, 32);
02142 
02143             switch (bits) {
02144             case 0x5a5a5a5a: {
02145                 int ext_amode, xch_fsize;
02146 
02147                 s->xch_base_channel = s->prim_channels;
02148 
02149                 /* validate sync word using XCHFSIZE field */
02150                 xch_fsize = show_bits(&s->gb, 10);
02151                 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
02152                     (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
02153                     continue;
02154 
02155                 /* skip length-to-end-of-frame field for the moment */
02156                 skip_bits(&s->gb, 10);
02157 
02158                 s->core_ext_mask |= DCA_EXT_XCH;
02159 
02160                 /* extension amode(number of channels in extension) should be 1 */
02161                 /* AFAIK XCh is not used for more channels */
02162                 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
02163                     av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
02164                            " supported!\n", ext_amode);
02165                     continue;
02166                 }
02167 
02168                 if (s->xch_base_channel < 2) {
02169                     av_log_ask_for_sample(avctx, "XCh with fewer than 2 base channels is not supported\n");
02170                     continue;
02171                 }
02172 
02173                 /* much like core primary audio coding header */
02174                 dca_parse_audio_coding_header(s, s->xch_base_channel, 0);
02175 
02176                 for (i = 0; i < (s->sample_blocks / 8); i++)
02177                     if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
02178                         av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
02179                         continue;
02180                     }
02181 
02182                 s->xch_present = 1;
02183                 break;
02184             }
02185             case 0x47004a03:
02186                 /* XXCh: extended channels */
02187                 /* usually found either in core or HD part in DTS-HD HRA streams,
02188                  * but not in DTS-ES which contains XCh extensions instead */
02189                 s->core_ext_mask |= DCA_EXT_XXCH;
02190                 dca_xxch_decode_frame(s);
02191                 break;
02192 
02193             case 0x1d95f262: {
02194                 int fsize96 = show_bits(&s->gb, 12) + 1;
02195                 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
02196                     continue;
02197 
02198                 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
02199                        get_bits_count(&s->gb));
02200                 skip_bits(&s->gb, 12);
02201                 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
02202                 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
02203 
02204                 s->core_ext_mask |= DCA_EXT_X96;
02205                 break;
02206             }
02207             }
02208 
02209             skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
02210         }
02211     } else {
02212         /* no supported extensions, skip the rest of the core substream */
02213         skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
02214     }
02215 
02216     if (s->core_ext_mask & DCA_EXT_X96)
02217         s->profile = FF_PROFILE_DTS_96_24;
02218     else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
02219         s->profile = FF_PROFILE_DTS_ES;
02220 
02221     /* check for ExSS (HD part) */
02222     if (s->dca_buffer_size - s->frame_size > 32 &&
02223         get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
02224         dca_exss_parse_header(s);
02225 
02226     avctx->profile = s->profile;
02227 
02228     full_channels = channels = s->prim_channels + !!s->lfe;
02229 
02230     /* If we have XXCH then the channel layout is managed differently */
02231     /* note that XLL will also have another way to do things */
02232     if (!(s->core_ext_mask & DCA_EXT_XXCH)
02233         || (s->core_ext_mask & DCA_EXT_XXCH && avctx->request_channels > 0
02234             && avctx->request_channels
02235             < num_core_channels + !!s->lfe + s->xxch_chset_nch[0]))
02236     { /* xxx should also do MA extensions */
02237         if (s->amode < 16) {
02238             avctx->channel_layout = dca_core_channel_layout[s->amode];
02239 
02240             if (s->xch_present && (!avctx->request_channels ||
02241                                    avctx->request_channels
02242                                    > num_core_channels + !!s->lfe)) {
02243                 avctx->channel_layout |= AV_CH_BACK_CENTER;
02244                 if (s->lfe) {
02245                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
02246                     s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
02247                 } else {
02248                     s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
02249                 }
02250                 if (s->channel_order_tab[s->xch_base_channel] < 0)
02251                     return AVERROR_INVALIDDATA;
02252             } else {
02253                 channels = num_core_channels + !!s->lfe;
02254                 s->xch_present = 0; /* disable further xch processing */
02255                 if (s->lfe) {
02256                     avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
02257                     s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
02258                 } else
02259                     s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
02260             }
02261 
02262             if (channels > !!s->lfe &&
02263                 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
02264                 return AVERROR_INVALIDDATA;
02265 
02266             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != channels) {
02267                 av_log(avctx, AV_LOG_ERROR, "Number of channels %d mismatches layout %d\n", channels, av_get_channel_layout_nb_channels(avctx->channel_layout));
02268                 return AVERROR_INVALIDDATA;
02269             }
02270 
02271             if (avctx->request_channels == 2 && s->prim_channels > 2) {
02272                 channels = 2;
02273                 s->output = DCA_STEREO;
02274                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
02275             }
02276             else if (avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE) {
02277                 static const int8_t dca_channel_order_native[9] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
02278                 s->channel_order_tab = dca_channel_order_native;
02279             }
02280             s->lfe_index = dca_lfe_index[s->amode];
02281         } else {
02282             av_log(avctx, AV_LOG_ERROR,
02283                    "Non standard configuration %d !\n", s->amode);
02284             return AVERROR_INVALIDDATA;
02285         }
02286 
02287         s->xxch_dmix_embedded = 0;
02288     } else {
02289         /* we only get here if an XXCH channel set can be added to the mix */
02290         channel_mask = s->xxch_core_spkmask;
02291 
02292         if (avctx->request_channels > 0
02293             && avctx->request_channels < s->prim_channels) {
02294             channels = num_core_channels + !!s->lfe;
02295             for (i = 0; i < s->xxch_chset && channels + s->xxch_chset_nch[i]
02296                                               <= avctx->request_channels; i++) {
02297                 channels += s->xxch_chset_nch[i];
02298                 channel_mask |= s->xxch_spk_masks[i];
02299             }
02300         } else {
02301             channels = s->prim_channels + !!s->lfe;
02302             for (i = 0; i < s->xxch_chset; i++) {
02303                 channel_mask |= s->xxch_spk_masks[i];
02304             }
02305         }
02306 
02307         /* Given the DTS spec'ed channel mask, generate an avcodec version */
02308         channel_layout = 0;
02309         for (i = 0; i < s->xxch_nbits_spk_mask; ++i) {
02310             if (channel_mask & (1 << i)) {
02311                 channel_layout |= map_xxch_to_native[i];
02312             }
02313         }
02314 
02315         /* make sure that we have managed to get equivelant dts/avcodec channel
02316          * masks in some sense -- unfortunately some channels could overlap */
02317         if (av_popcount(channel_mask) != av_popcount(channel_layout)) {
02318             av_log(avctx, AV_LOG_DEBUG,
02319                    "DTS-XXCH: Inconsistant avcodec/dts channel layouts\n");
02320             return AVERROR_INVALIDDATA;
02321         }
02322 
02323         avctx->channel_layout = channel_layout;
02324 
02325         if (!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE)) {
02326             /* Estimate DTS --> avcodec ordering table */
02327             for (chset = -1, j = 0; chset < s->xxch_chset; ++chset) {
02328                 mask = chset >= 0 ? s->xxch_spk_masks[chset]
02329                                   : s->xxch_core_spkmask;
02330                 for (i = 0; i < s->xxch_nbits_spk_mask; i++) {
02331                     if (mask & ~(DCA_XXCH_LFE1 | DCA_XXCH_LFE2) & (1 << i)) {
02332                         lavc = map_xxch_to_native[i];
02333                         posn = av_popcount(channel_layout & (lavc - 1));
02334                         s->xxch_order_tab[j++] = posn;
02335                     }
02336                 }
02337             }
02338 
02339             s->lfe_index = av_popcount(channel_layout & (AV_CH_LOW_FREQUENCY-1));
02340         } else { /* native ordering */
02341             for (i = 0; i < channels; i++)
02342                 s->xxch_order_tab[i] = i;
02343 
02344             s->lfe_index = channels - 1;
02345         }
02346 
02347         s->channel_order_tab = s->xxch_order_tab;
02348     }
02349 
02350     if (avctx->channels != channels) {
02351         if (avctx->channels)
02352             av_log(avctx, AV_LOG_INFO, "Number of channels changed in DCA decoder (%d -> %d)\n", avctx->channels, channels);
02353         avctx->channels = channels;
02354     }
02355 
02356     /* get output buffer */
02357     s->frame.nb_samples = 256 * (s->sample_blocks / 8);
02358     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
02359         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
02360         return ret;
02361     }
02362     samples_flt = (float  **) s->frame.extended_data;
02363 
02364     /* allocate buffer for extra channels if downmixing */
02365     if (avctx->channels < full_channels) {
02366         ret = av_samples_get_buffer_size(NULL, full_channels - channels,
02367                                          s->frame.nb_samples,
02368                                          avctx->sample_fmt, 0);
02369         if (ret < 0)
02370             return ret;
02371 
02372         av_fast_malloc(&s->extra_channels_buffer,
02373                        &s->extra_channels_buffer_size, ret);
02374         if (!s->extra_channels_buffer)
02375             return AVERROR(ENOMEM);
02376 
02377         ret = av_samples_fill_arrays((uint8_t **)s->extra_channels, NULL,
02378                                      s->extra_channels_buffer,
02379                                      full_channels - channels,
02380                                      s->frame.nb_samples, avctx->sample_fmt, 0);
02381         if (ret < 0)
02382             return ret;
02383     }
02384 
02385     /* filter to get final output */
02386     for (i = 0; i < (s->sample_blocks / 8); i++) {
02387         int ch;
02388 
02389         for (ch = 0; ch < channels; ch++)
02390             s->samples_chanptr[ch] = samples_flt[ch] + i * 256;
02391         for (; ch < full_channels; ch++)
02392             s->samples_chanptr[ch] = s->extra_channels[ch - channels] + i * 256;
02393 
02394         dca_filter_channels(s, i);
02395 
02396         /* If this was marked as a DTS-ES stream we need to subtract back- */
02397         /* channel from SL & SR to remove matrixed back-channel signal */
02398         if ((s->source_pcm_res & 1) && s->xch_present) {
02399             float *back_chan = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel]];
02400             float *lt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 2]];
02401             float *rt_chan   = s->samples_chanptr[s->channel_order_tab[s->xch_base_channel - 1]];
02402             s->fdsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
02403             s->fdsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
02404         }
02405 
02406         /* If stream contains XXCH, we might need to undo an embedded downmix */
02407         if (s->xxch_dmix_embedded) {
02408             /* Loop over channel sets in turn */
02409             ch = num_core_channels;
02410             for (chset = 0; chset < s->xxch_chset; chset++) {
02411                 endch = ch + s->xxch_chset_nch[chset];
02412                 mask = s->xxch_dmix_embedded;
02413 
02414                 /* undo downmix */
02415                 for (j = ch; j < endch; j++) {
02416                     if (mask & (1 << j)) { /* this channel has been mixed-out */
02417                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
02418                         for (k = 0; k < endch; k++) {
02419                             achan = s->channel_order_tab[k];
02420                             scale = s->xxch_dmix_coeff[j][k];
02421                             if (scale != 0.0) {
02422                                 dst_chan = s->samples_chanptr[achan];
02423                                 s->fdsp.vector_fmac_scalar(dst_chan, src_chan,
02424                                                            -scale, 256);
02425                             }
02426                         }
02427                     }
02428                 }
02429 
02430                 /* if a downmix has been embedded then undo the pre-scaling */
02431                 if ((mask & (1 << ch)) && s->xxch_dmix_sf[chset] != 1.0f) {
02432                     scale = s->xxch_dmix_sf[chset];
02433 
02434                     for (j = 0; j < ch; j++) {
02435                         src_chan = s->samples_chanptr[s->channel_order_tab[j]];
02436                         for (k = 0; k < 256; k++)
02437                             src_chan[k] *= scale;
02438                     }
02439 
02440                     /* LFE channel is always part of core, scale if it exists */
02441                     if (s->lfe) {
02442                         src_chan = s->samples_chanptr[s->lfe_index];
02443                         for (k = 0; k < 256; k++)
02444                             src_chan[k] *= scale;
02445                     }
02446                 }
02447 
02448                 ch = endch;
02449             }
02450 
02451         }
02452     }
02453 
02454     /* update lfe history */
02455     lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
02456     for (i = 0; i < 2 * s->lfe * 4; i++)
02457         s->lfe_data[i] = s->lfe_data[i + lfe_samples];
02458 
02459     *got_frame_ptr    = 1;
02460     *(AVFrame *) data = s->frame;
02461 
02462     return buf_size;
02463 }
02464 
02465 
02466 
02473 static av_cold int dca_decode_init(AVCodecContext *avctx)
02474 {
02475     DCAContext *s = avctx->priv_data;
02476 
02477     s->avctx = avctx;
02478     dca_init_vlcs();
02479 
02480     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
02481     ff_mdct_init(&s->imdct, 6, 1, 1.0);
02482     ff_synth_filter_init(&s->synth);
02483     ff_dcadsp_init(&s->dcadsp);
02484     ff_fmt_convert_init(&s->fmt_conv, avctx);
02485 
02486     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
02487 
02488     /* allow downmixing to stereo */
02489     if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
02490         avctx->request_channels == 2) {
02491         avctx->channels = avctx->request_channels;
02492     }
02493 
02494     avcodec_get_frame_defaults(&s->frame);
02495     avctx->coded_frame = &s->frame;
02496 
02497     return 0;
02498 }
02499 
02500 static av_cold int dca_decode_end(AVCodecContext *avctx)
02501 {
02502     DCAContext *s = avctx->priv_data;
02503     ff_mdct_end(&s->imdct);
02504     av_freep(&s->extra_channels_buffer);
02505     return 0;
02506 }
02507 
02508 static const AVProfile profiles[] = {
02509     { FF_PROFILE_DTS,        "DTS"        },
02510     { FF_PROFILE_DTS_ES,     "DTS-ES"     },
02511     { FF_PROFILE_DTS_96_24,  "DTS 96/24"  },
02512     { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
02513     { FF_PROFILE_DTS_HD_MA,  "DTS-HD MA"  },
02514     { FF_PROFILE_UNKNOWN },
02515 };
02516 
02517 AVCodec ff_dca_decoder = {
02518     .name            = "dca",
02519     .type            = AVMEDIA_TYPE_AUDIO,
02520     .id              = AV_CODEC_ID_DTS,
02521     .priv_data_size  = sizeof(DCAContext),
02522     .init            = dca_decode_init,
02523     .decode          = dca_decode_frame,
02524     .close           = dca_decode_end,
02525     .long_name       = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
02526     .capabilities    = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
02527     .sample_fmts     = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
02528                                                        AV_SAMPLE_FMT_NONE },
02529     .profiles        = NULL_IF_CONFIG_SMALL(profiles),
02530 };