00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
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
00046
00047 #define DCA_PRIM_CHANNELS_MAX (7)
00048 #define DCA_SUBBANDS (32)
00049 #define DCA_ABITS_MAX (32)
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
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
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
00115 #define DCA_CORE_EXTS (DCA_EXT_XCH | DCA_EXT_XXCH | DCA_EXT_X96)
00116
00117
00118
00119
00120
00121
00122
00123
00124
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
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
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
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
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
00323 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
00324 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
00325 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
00326 int hist_index[DCA_PRIM_CHANNELS_MAX];
00327 DECLARE_ALIGNED(16, float, raXin)[32];
00328
00329 int output;
00330 float scale_bias;
00331
00332 DECLARE_ALIGNED(16, float, subband_samples)[DCA_BLOCKS_MAX][DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][8];
00333 DECLARE_ALIGNED(16, 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
00342 int current_subframe;
00343 int current_subsubframe;
00344
00345 int core_ext_mask;
00346
00347
00348 int xch_present;
00349 int xch_base_channel;
00350
00351
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
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
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
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
00519 get_bits(&s->gb, 32);
00520
00521
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
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
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
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
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
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
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
00643 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00644 }
00645 }
00646 }
00647
00648
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
00666
00667 return -1;
00668 }
00669 }
00670 }
00671
00672
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
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
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
00716 for (j = base_channel; j < s->prim_channels; j++) {
00717
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
00726 for (j = base_channel; j < s->prim_channels; j++) {
00727 int source_channel;
00728
00729
00730 if (s->joint_intensity[j] > 0) {
00731 int scale = 0;
00732 source_channel = s->joint_intensity[j] - 1;
00733
00734
00735
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;
00740 s->joint_scale_factor[j][k] = 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
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
00768 if (!base_channel && s->dynrange)
00769 s->dynrange_coef = get_bits(&s->gb, 8);
00770
00771
00772 if (s->crc_present) {
00773 get_bits(&s->gb, 16);
00774 }
00775
00776
00777
00778
00779
00780
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
00784 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00785
00786
00787 if (!base_channel && s->lfe) {
00788
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
00795 s->lfe_data[j] = get_sbits(&s->gb, 8);
00796 }
00797
00798
00799 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
00800
00801
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
00896 if (!s->multirate_inter)
00897 prCoeff = fir_32bands_nonperfect;
00898 else
00899 prCoeff = fir_32bands_perfect;
00900
00901
00902 for (subindex = 0; subindex < 8; subindex++) {
00903
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
00925
00926
00927
00928
00929
00930
00931
00932 int decifactor;
00933 const float *prCoeff;
00934 int deciindex;
00935
00936
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
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
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
01036
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
01067 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01068 LOCAL_ALIGNED_16(int, block, [8]);
01069
01070
01071
01072
01073
01074
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
01088 int abits = s->bitalloc[k][l];
01089
01090 float quant_step_size = quant_step_table[abits];
01091
01092
01093
01094
01095
01096
01097 int sel = s->quant_index_huffman[k][abits];
01098
01099
01100
01101
01102 if (!abits){
01103 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
01104 } else {
01105
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
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
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
01124 for (m = 0; m < 8; m++)
01125 block[m] = get_sbits(&s->gb, abits - 3);
01126 }
01127 }else{
01128
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
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
01159
01160 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01161
01162
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
01180 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
01181 if (0xFFFF == get_bits(&s->gb, 16)) {
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
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
01205 for (k = 0; k < s->prim_channels; k++) {
01206
01207
01208 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
01209 M_SQRT1_2*s->scale_bias );
01210 }
01211
01212
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
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
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
01236
01237
01238
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
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
01277 if (dca_subframe_header(s, base_channel, block_index))
01278 return -1;
01279 }
01280
01281
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
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
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
01320
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
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
01399
01400
01401 header_size = get_bits(&s->gb, 9) + 1;
01402 skip_bits(&s->gb, 3);
01403
01404 if (s->static_fields) {
01405 if (get_bits1(&s->gb))
01406 skip_bits(&s->gb, 4);
01407 if (get_bits1(&s->gb))
01408 skip_bits_long(&s->gb, 24);
01409
01410 if (get_bits1(&s->gb)) {
01411
01412
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);
01417 }
01418
01419 skip_bits(&s->gb, 5);
01420 skip_bits(&s->gb, 4);
01421 channels = get_bits(&s->gb, 8) + 1;
01422
01423 if (get_bits1(&s->gb)) {
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);
01436 }
01437
01438 spkr_remap_sets = get_bits(&s->gb, 3);
01439
01440 for (i = 0; i < spkr_remap_sets; i++) {
01441
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);
01454 }
01455 }
01456
01457 } else {
01458 skip_bits(&s->gb, 3);
01459 }
01460 }
01461
01462 drc_code_present = get_bits1(&s->gb);
01463 if (drc_code_present)
01464 get_bits(&s->gb, 8);
01465
01466 if (get_bits1(&s->gb))
01467 skip_bits(&s->gb, 5);
01468
01469 if (drc_code_present && embedded_stereo)
01470 get_bits(&s->gb, 8);
01471
01472 if (s->mix_metadata && get_bits1(&s->gb)) {
01473 skip_bits(&s->gb, 1);
01474 skip_bits(&s->gb, 6);
01475
01476 if (get_bits(&s->gb, 2) != 3)
01477 skip_bits(&s->gb, 3);
01478 else
01479 skip_bits(&s->gb, 8);
01480
01481 if (get_bits1(&s->gb))
01482 for (i = 0; i < s->num_mix_configs; i++)
01483 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6);
01484 else
01485 skip_bits_long(&s->gb, s->num_mix_configs * 6);
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; break;
01503 }
01504
01505
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 header_size;
01539 int hd_size;
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);
01549 ss_index = get_bits(&s->gb, 2);
01550
01551 blownup = get_bits1(&s->gb);
01552 header_size = get_bits(&s->gb, 8 + 4 * blownup) + 1;
01553 hd_size = get_bits_long(&s->gb, 16 + 4 * blownup) + 1;
01554
01555 s->static_fields = get_bits1(&s->gb);
01556 if (s->static_fields) {
01557 skip_bits(&s->gb, 2);
01558 skip_bits(&s->gb, 3);
01559
01560 if (get_bits1(&s->gb))
01561 skip_bits_long(&s->gb, 36);
01562
01563
01564
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
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
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);
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);
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);
01605
01606 for (i = 0; i < num_assets; i++) {
01607 if (dca_exss_parse_asset_header(s))
01608 return;
01609 }
01610
01611
01612
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 int16_t *samples = data;
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
01647 *data_size=0;
01648 return buf_size;
01649 }
01650
01651 avctx->sample_rate = s->sample_rate;
01652 avctx->bit_rate = s->bit_rate;
01653
01654 s->profile = FF_PROFILE_DTS;
01655
01656 for (i = 0; i < (s->sample_blocks / 8); i++) {
01657 dca_decode_block(s, 0, i);
01658 }
01659
01660
01661 num_core_channels = s->prim_channels;
01662
01663 if (s->ext_coding)
01664 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
01665 else
01666 s->core_ext_mask = 0;
01667
01668 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
01669
01670
01671
01672 if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
01673
01674
01675
01676 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
01677
01678
01679 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01680
01681 while(core_ss_end - get_bits_count(&s->gb) >= 32) {
01682 uint32_t bits = get_bits_long(&s->gb, 32);
01683
01684 switch(bits) {
01685 case 0x5a5a5a5a: {
01686 int ext_amode, xch_fsize;
01687
01688 s->xch_base_channel = s->prim_channels;
01689
01690
01691 xch_fsize = show_bits(&s->gb, 10);
01692 if((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
01693 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
01694 continue;
01695
01696
01697 skip_bits(&s->gb, 10);
01698
01699 s->core_ext_mask |= DCA_EXT_XCH;
01700
01701
01702
01703 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
01704 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
01705 " supported!\n",ext_amode);
01706 continue;
01707 }
01708
01709
01710 dca_parse_audio_coding_header(s, s->xch_base_channel);
01711
01712 for (i = 0; i < (s->sample_blocks / 8); i++) {
01713 dca_decode_block(s, s->xch_base_channel, i);
01714 }
01715
01716 s->xch_present = 1;
01717 break;
01718 }
01719 case 0x47004a03:
01720
01721
01722
01723 s->core_ext_mask |= DCA_EXT_XXCH;
01724 break;
01725
01726 case 0x1d95f262: {
01727 int fsize96 = show_bits(&s->gb, 12) + 1;
01728 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
01729 continue;
01730
01731 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n", get_bits_count(&s->gb));
01732 skip_bits(&s->gb, 12);
01733 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
01734 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
01735
01736 s->core_ext_mask |= DCA_EXT_X96;
01737 break;
01738 }
01739 }
01740
01741 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01742 }
01743
01744 } else {
01745
01746 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
01747 }
01748
01749 if (s->core_ext_mask & DCA_EXT_X96)
01750 s->profile = FF_PROFILE_DTS_96_24;
01751 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
01752 s->profile = FF_PROFILE_DTS_ES;
01753
01754
01755 if (s->dca_buffer_size - s->frame_size > 32
01756 && get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
01757 dca_exss_parse_header(s);
01758
01759 avctx->profile = s->profile;
01760
01761 channels = s->prim_channels + !!s->lfe;
01762
01763 if (s->amode<16) {
01764 avctx->channel_layout = dca_core_channel_layout[s->amode];
01765
01766 if (s->xch_present && (!avctx->request_channels ||
01767 avctx->request_channels > num_core_channels + !!s->lfe)) {
01768 avctx->channel_layout |= AV_CH_BACK_CENTER;
01769 if (s->lfe) {
01770 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01771 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
01772 } else {
01773 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
01774 }
01775 } else {
01776 channels = num_core_channels + !!s->lfe;
01777 s->xch_present = 0;
01778 if (s->lfe) {
01779 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01780 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
01781 } else
01782 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
01783 }
01784
01785 if (channels > !!s->lfe &&
01786 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
01787 return -1;
01788
01789 if (avctx->request_channels == 2 && s->prim_channels > 2) {
01790 channels = 2;
01791 s->output = DCA_STEREO;
01792 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
01793 }
01794 } else {
01795 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
01796 return -1;
01797 }
01798
01799
01800
01801
01802
01803
01804
01805 if (s->is_channels_set == 0) {
01806 s->is_channels_set = 1;
01807 avctx->channels = channels;
01808 }
01809 if (avctx->channels != channels) {
01810 av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
01811 "channels changing in stream. Skipping frame.\n");
01812 return -1;
01813 }
01814
01815 if (*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
01816 return -1;
01817 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
01818
01819
01820 for (i = 0; i < (s->sample_blocks / 8); i++) {
01821 dca_filter_channels(s, i);
01822
01823
01824
01825 if((s->source_pcm_res & 1) && s->xch_present) {
01826 float* back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
01827 float* lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
01828 float* rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
01829 int j;
01830 for(j = 0; j < 256; ++j) {
01831 lt_chan[j] -= back_chan[j] * M_SQRT1_2;
01832 rt_chan[j] -= back_chan[j] * M_SQRT1_2;
01833 }
01834 }
01835
01836 s->fmt_conv.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
01837 samples += 256 * channels;
01838 }
01839
01840
01841 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
01842 for (i = 0; i < 2 * s->lfe * 4; i++) {
01843 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
01844 }
01845
01846 return buf_size;
01847 }
01848
01849
01850
01857 static av_cold int dca_decode_init(AVCodecContext * avctx)
01858 {
01859 DCAContext *s = avctx->priv_data;
01860 int i;
01861
01862 s->avctx = avctx;
01863 dca_init_vlcs();
01864
01865 dsputil_init(&s->dsp, avctx);
01866 ff_mdct_init(&s->imdct, 6, 1, 1.0);
01867 ff_synth_filter_init(&s->synth);
01868 ff_dcadsp_init(&s->dcadsp);
01869 ff_fmt_convert_init(&s->fmt_conv, avctx);
01870
01871 for (i = 0; i < DCA_PRIM_CHANNELS_MAX+1; i++)
01872 s->samples_chanptr[i] = s->samples + i * 256;
01873 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01874
01875 s->scale_bias = 1.0;
01876
01877
01878 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
01879 avctx->request_channels == 2) {
01880 avctx->channels = avctx->request_channels;
01881 }
01882
01883 return 0;
01884 }
01885
01886 static av_cold int dca_decode_end(AVCodecContext * avctx)
01887 {
01888 DCAContext *s = avctx->priv_data;
01889 ff_mdct_end(&s->imdct);
01890 return 0;
01891 }
01892
01893 static const AVProfile profiles[] = {
01894 { FF_PROFILE_DTS, "DTS" },
01895 { FF_PROFILE_DTS_ES, "DTS-ES" },
01896 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
01897 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
01898 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
01899 { FF_PROFILE_UNKNOWN },
01900 };
01901
01902 AVCodec ff_dca_decoder = {
01903 .name = "dca",
01904 .type = AVMEDIA_TYPE_AUDIO,
01905 .id = CODEC_ID_DTS,
01906 .priv_data_size = sizeof(DCAContext),
01907 .init = dca_decode_init,
01908 .decode = dca_decode_frame,
01909 .close = dca_decode_end,
01910 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
01911 .capabilities = CODEC_CAP_CHANNEL_CONF,
01912 .profiles = NULL_IF_CONFIG_SMALL(profiles),
01913 };