• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • Examples
  • File List
  • Globals

libavcodec/dca.c

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