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