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