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