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