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
00582 if (s->crc_present)
00583 s->header_crc = get_bits(&s->gb, 16);
00584
00585 s->multirate_inter = get_bits(&s->gb, 1);
00586 s->version = get_bits(&s->gb, 4);
00587 s->copy_history = get_bits(&s->gb, 2);
00588 s->source_pcm_res = get_bits(&s->gb, 3);
00589 s->front_sum = get_bits(&s->gb, 1);
00590 s->surround_sum = get_bits(&s->gb, 1);
00591 s->dialog_norm = get_bits(&s->gb, 4);
00592
00593
00594 s->output = s->amode;
00595 if (s->lfe)
00596 s->output |= DCA_LFE;
00597
00598 #ifdef TRACE
00599 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
00600 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
00601 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
00602 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
00603 s->sample_blocks, s->sample_blocks * 32);
00604 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
00605 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
00606 s->amode, dca_channels[s->amode]);
00607 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
00608 s->sample_rate);
00609 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
00610 s->bit_rate);
00611 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
00612 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
00613 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
00614 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
00615 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
00616 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
00617 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
00618 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
00619 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
00620 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
00621 s->predictor_history);
00622 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
00623 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
00624 s->multirate_inter);
00625 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
00626 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
00627 av_log(s->avctx, AV_LOG_DEBUG,
00628 "source pcm resolution: %i (%i bits/sample)\n",
00629 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
00630 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
00631 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
00632 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
00633 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00634 #endif
00635
00636
00637 s->subframes = get_bits(&s->gb, 4) + 1;
00638
00639 return dca_parse_audio_coding_header(s, 0);
00640 }
00641
00642
00643 static inline int get_scale(GetBitContext *gb, int level, int value, int log2range)
00644 {
00645 if (level < 5) {
00646
00647 value += get_bitalloc(gb, &dca_scalefactor, level);
00648 value = av_clip(value, 0, (1 << log2range) - 1);
00649 } else if (level < 8) {
00650 if (level + 1 > log2range) {
00651 skip_bits(gb, level + 1 - log2range);
00652 value = get_bits(gb, log2range);
00653 } else {
00654 value = get_bits(gb, level + 1);
00655 }
00656 }
00657 return value;
00658 }
00659
00660 static int dca_subframe_header(DCAContext *s, int base_channel, int block_index)
00661 {
00662
00663 int j, k;
00664
00665 if (get_bits_left(&s->gb) < 0)
00666 return AVERROR_INVALIDDATA;
00667
00668 if (!base_channel) {
00669 s->subsubframes[s->current_subframe] = get_bits(&s->gb, 2) + 1;
00670 s->partial_samples[s->current_subframe] = get_bits(&s->gb, 3);
00671 }
00672
00673 for (j = base_channel; j < s->prim_channels; j++) {
00674 for (k = 0; k < s->subband_activity[j]; k++)
00675 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
00676 }
00677
00678
00679 for (j = base_channel; j < s->prim_channels; j++) {
00680 for (k = 0; k < s->subband_activity[j]; k++) {
00681 if (s->prediction_mode[j][k] > 0) {
00682
00683 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00684 }
00685 }
00686 }
00687
00688
00689 for (j = base_channel; j < s->prim_channels; j++) {
00690 for (k = 0; k < s->vq_start_subband[j]; k++) {
00691 if (s->bitalloc_huffman[j] == 6)
00692 s->bitalloc[j][k] = get_bits(&s->gb, 5);
00693 else if (s->bitalloc_huffman[j] == 5)
00694 s->bitalloc[j][k] = get_bits(&s->gb, 4);
00695 else if (s->bitalloc_huffman[j] == 7) {
00696 av_log(s->avctx, AV_LOG_ERROR,
00697 "Invalid bit allocation index\n");
00698 return AVERROR_INVALIDDATA;
00699 } else {
00700 s->bitalloc[j][k] =
00701 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
00702 }
00703
00704 if (s->bitalloc[j][k] > 26) {
00705
00706
00707 return AVERROR_INVALIDDATA;
00708 }
00709 }
00710 }
00711
00712
00713 for (j = base_channel; j < s->prim_channels; j++) {
00714 for (k = 0; k < s->subband_activity[j]; k++) {
00715 s->transition_mode[j][k] = 0;
00716 if (s->subsubframes[s->current_subframe] > 1 &&
00717 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
00718 s->transition_mode[j][k] =
00719 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
00720 }
00721 }
00722 }
00723
00724 if (get_bits_left(&s->gb) < 0)
00725 return AVERROR_INVALIDDATA;
00726
00727 for (j = base_channel; j < s->prim_channels; j++) {
00728 const uint32_t *scale_table;
00729 int scale_sum, log_size;
00730
00731 memset(s->scale_factor[j], 0,
00732 s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
00733
00734 if (s->scalefactor_huffman[j] == 6) {
00735 scale_table = scale_factor_quant7;
00736 log_size = 7;
00737 } else {
00738 scale_table = scale_factor_quant6;
00739 log_size = 6;
00740 }
00741
00742
00743 scale_sum = 0;
00744
00745 for (k = 0; k < s->subband_activity[j]; k++) {
00746 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
00747 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00748 s->scale_factor[j][k][0] = scale_table[scale_sum];
00749 }
00750
00751 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
00752
00753 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum, log_size);
00754 s->scale_factor[j][k][1] = scale_table[scale_sum];
00755 }
00756 }
00757 }
00758
00759
00760 for (j = base_channel; j < s->prim_channels; j++) {
00761
00762 if (s->joint_intensity[j] > 0)
00763 s->joint_huff[j] = get_bits(&s->gb, 3);
00764 }
00765
00766 if (get_bits_left(&s->gb) < 0)
00767 return AVERROR_INVALIDDATA;
00768
00769
00770 for (j = base_channel; j < s->prim_channels; j++) {
00771 int source_channel;
00772
00773
00774 if (s->joint_intensity[j] > 0) {
00775 int scale = 0;
00776 source_channel = s->joint_intensity[j] - 1;
00777
00778
00779
00780
00781 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
00782 scale = get_scale(&s->gb, s->joint_huff[j], 64 , 7);
00783 s->joint_scale_factor[j][k] = scale;
00784 }
00785
00786 if (!(s->debug_flag & 0x02)) {
00787 av_log(s->avctx, AV_LOG_DEBUG,
00788 "Joint stereo coding not supported\n");
00789 s->debug_flag |= 0x02;
00790 }
00791 }
00792 }
00793
00794
00795 if (!base_channel && s->prim_channels > 2) {
00796 if (s->downmix) {
00797 for (j = base_channel; j < s->prim_channels; j++) {
00798 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
00799 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
00800 }
00801 } else {
00802 int am = s->amode & DCA_CHANNEL_MASK;
00803 if (am >= FF_ARRAY_ELEMS(dca_default_coeffs)) {
00804 av_log(s->avctx, AV_LOG_ERROR,
00805 "Invalid channel mode %d\n", am);
00806 return AVERROR_INVALIDDATA;
00807 }
00808 for (j = base_channel; j < s->prim_channels; j++) {
00809 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
00810 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
00811 }
00812 }
00813 }
00814
00815
00816 if (!base_channel && s->dynrange)
00817 s->dynrange_coef = get_bits(&s->gb, 8);
00818
00819
00820 if (s->crc_present) {
00821 get_bits(&s->gb, 16);
00822 }
00823
00824
00825
00826
00827
00828
00829 for (j = base_channel; j < s->prim_channels; j++)
00830 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00831
00832 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00833
00834
00835 if (!base_channel && s->lfe) {
00836
00837 int lfe_samples = 2 * s->lfe * (4 + block_index);
00838 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00839 float lfe_scale;
00840
00841 for (j = lfe_samples; j < lfe_end_sample; j++) {
00842
00843 s->lfe_data[j] = get_sbits(&s->gb, 8);
00844 }
00845
00846
00847 skip_bits(&s->gb, 1);
00848 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 7)];
00849
00850
00851 lfe_scale = 0.035 * s->lfe_scale_factor;
00852
00853 for (j = lfe_samples; j < lfe_end_sample; j++)
00854 s->lfe_data[j] *= lfe_scale;
00855 }
00856
00857 #ifdef TRACE
00858 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n",
00859 s->subsubframes[s->current_subframe]);
00860 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
00861 s->partial_samples[s->current_subframe]);
00862
00863 for (j = base_channel; j < s->prim_channels; j++) {
00864 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
00865 for (k = 0; k < s->subband_activity[j]; k++)
00866 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
00867 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00868 }
00869 for (j = base_channel; j < s->prim_channels; j++) {
00870 for (k = 0; k < s->subband_activity[j]; k++)
00871 av_log(s->avctx, AV_LOG_DEBUG,
00872 "prediction coefs: %f, %f, %f, %f\n",
00873 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
00874 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
00875 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
00876 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
00877 }
00878 for (j = base_channel; j < s->prim_channels; j++) {
00879 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
00880 for (k = 0; k < s->vq_start_subband[j]; k++)
00881 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
00882 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00883 }
00884 for (j = base_channel; j < s->prim_channels; j++) {
00885 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
00886 for (k = 0; k < s->subband_activity[j]; k++)
00887 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
00888 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00889 }
00890 for (j = base_channel; j < s->prim_channels; j++) {
00891 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
00892 for (k = 0; k < s->subband_activity[j]; k++) {
00893 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
00894 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
00895 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
00896 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
00897 }
00898 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00899 }
00900 for (j = base_channel; j < s->prim_channels; j++) {
00901 if (s->joint_intensity[j] > 0) {
00902 int source_channel = s->joint_intensity[j] - 1;
00903 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
00904 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
00905 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
00906 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00907 }
00908 }
00909 if (!base_channel && s->prim_channels > 2 && s->downmix) {
00910 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
00911 for (j = 0; j < s->prim_channels; j++) {
00912 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0, %d = %f\n", j,
00913 dca_downmix_coeffs[s->downmix_coef[j][0]]);
00914 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1, %d = %f\n", j,
00915 dca_downmix_coeffs[s->downmix_coef[j][1]]);
00916 }
00917 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00918 }
00919 for (j = base_channel; j < s->prim_channels; j++)
00920 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00921 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
00922 if (!base_channel && s->lfe) {
00923 int lfe_samples = 2 * s->lfe * (4 + block_index);
00924 int lfe_end_sample = 2 * s->lfe * (4 + block_index + s->subsubframes[s->current_subframe]);
00925
00926 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
00927 for (j = lfe_samples; j < lfe_end_sample; j++)
00928 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
00929 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00930 }
00931 #endif
00932
00933 return 0;
00934 }
00935
00936 static void qmf_32_subbands(DCAContext *s, int chans,
00937 float samples_in[32][8], float *samples_out,
00938 float scale)
00939 {
00940 const float *prCoeff;
00941 int i;
00942
00943 int sb_act = s->subband_activity[chans];
00944 int subindex;
00945
00946 scale *= sqrt(1 / 8.0);
00947
00948
00949 if (!s->multirate_inter)
00950 prCoeff = fir_32bands_nonperfect;
00951 else
00952 prCoeff = fir_32bands_perfect;
00953
00954 for (i = sb_act; i < 32; i++)
00955 s->raXin[i] = 0.0;
00956
00957
00958 for (subindex = 0; subindex < 8; subindex++) {
00959
00960 for (i = 0; i < sb_act; i++) {
00961 unsigned sign = (i - 1) & 2;
00962 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ sign << 30;
00963 AV_WN32A(&s->raXin[i], v);
00964 }
00965
00966 s->synth.synth_filter_float(&s->imdct,
00967 s->subband_fir_hist[chans],
00968 &s->hist_index[chans],
00969 s->subband_fir_noidea[chans], prCoeff,
00970 samples_out, s->raXin, scale);
00971 samples_out += 32;
00972 }
00973 }
00974
00975 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
00976 int num_deci_sample, float *samples_in,
00977 float *samples_out, float scale)
00978 {
00979
00980
00981
00982
00983
00984
00985
00986
00987 int decifactor;
00988 const float *prCoeff;
00989 int deciindex;
00990
00991
00992 if (decimation_select == 1) {
00993 decifactor = 64;
00994 prCoeff = lfe_fir_128;
00995 } else {
00996 decifactor = 32;
00997 prCoeff = lfe_fir_64;
00998 }
00999
01000 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
01001 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor, scale);
01002 samples_in++;
01003 samples_out += 2 * decifactor;
01004 }
01005 }
01006
01007
01008 #define MIX_REAR1(samples, si1, rs, coef) \
01009 samples[i] += samples[si1] * coef[rs][0]; \
01010 samples[i+256] += samples[si1] * coef[rs][1];
01011
01012 #define MIX_REAR2(samples, si1, si2, rs, coef) \
01013 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs + 1][0]; \
01014 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs + 1][1];
01015
01016 #define MIX_FRONT3(samples, coef) \
01017 t = samples[i + c]; \
01018 u = samples[i + l]; \
01019 v = samples[i + r]; \
01020 samples[i] = t * coef[0][0] + u * coef[1][0] + v * coef[2][0]; \
01021 samples[i+256] = t * coef[0][1] + u * coef[1][1] + v * coef[2][1];
01022
01023 #define DOWNMIX_TO_STEREO(op1, op2) \
01024 for (i = 0; i < 256; i++) { \
01025 op1 \
01026 op2 \
01027 }
01028
01029 static void dca_downmix(float *samples, int srcfmt,
01030 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2],
01031 const int8_t *channel_mapping)
01032 {
01033 int c, l, r, sl, sr, s;
01034 int i;
01035 float t, u, v;
01036 float coef[DCA_PRIM_CHANNELS_MAX][2];
01037
01038 for (i = 0; i < DCA_PRIM_CHANNELS_MAX; i++) {
01039 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
01040 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
01041 }
01042
01043 switch (srcfmt) {
01044 case DCA_MONO:
01045 case DCA_CHANNEL:
01046 case DCA_STEREO_TOTAL:
01047 case DCA_STEREO_SUMDIFF:
01048 case DCA_4F2R:
01049 av_log(NULL, 0, "Not implemented!\n");
01050 break;
01051 case DCA_STEREO:
01052 break;
01053 case DCA_3F:
01054 c = channel_mapping[0] * 256;
01055 l = channel_mapping[1] * 256;
01056 r = channel_mapping[2] * 256;
01057 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef), );
01058 break;
01059 case DCA_2F1R:
01060 s = channel_mapping[2] * 256;
01061 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + s, 2, coef), );
01062 break;
01063 case DCA_3F1R:
01064 c = channel_mapping[0] * 256;
01065 l = channel_mapping[1] * 256;
01066 r = channel_mapping[2] * 256;
01067 s = channel_mapping[3] * 256;
01068 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01069 MIX_REAR1(samples, i + s, 3, coef));
01070 break;
01071 case DCA_2F2R:
01072 sl = channel_mapping[2] * 256;
01073 sr = channel_mapping[3] * 256;
01074 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + sl, i + sr, 2, coef), );
01075 break;
01076 case DCA_3F2R:
01077 c = channel_mapping[0] * 256;
01078 l = channel_mapping[1] * 256;
01079 r = channel_mapping[2] * 256;
01080 sl = channel_mapping[3] * 256;
01081 sr = channel_mapping[4] * 256;
01082 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
01083 MIX_REAR2(samples, i + sl, i + sr, 3, coef));
01084 break;
01085 }
01086 }
01087
01088
01089 #ifndef decode_blockcodes
01090
01091
01092 static int decode_blockcode(int code, int levels, int *values)
01093 {
01094 int i;
01095 int offset = (levels - 1) >> 1;
01096
01097 for (i = 0; i < 4; i++) {
01098 int div = FASTDIV(code, levels);
01099 values[i] = code - offset - div * levels;
01100 code = div;
01101 }
01102
01103 return code;
01104 }
01105
01106 static int decode_blockcodes(int code1, int code2, int levels, int *values)
01107 {
01108 return decode_blockcode(code1, levels, values) |
01109 decode_blockcode(code2, levels, values + 4);
01110 }
01111 #endif
01112
01113 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
01114 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
01115
01116 #ifndef int8x8_fmul_int32
01117 static inline void int8x8_fmul_int32(float *dst, const int8_t *src, int scale)
01118 {
01119 float fscale = scale / 16.0;
01120 int i;
01121 for (i = 0; i < 8; i++)
01122 dst[i] = src[i] * fscale;
01123 }
01124 #endif
01125
01126 static int dca_subsubframe(DCAContext *s, int base_channel, int block_index)
01127 {
01128 int k, l;
01129 int subsubframe = s->current_subsubframe;
01130
01131 const float *quant_step_table;
01132
01133
01134 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01135 LOCAL_ALIGNED_16(int, block, [8]);
01136
01137
01138
01139
01140
01141
01142 if (s->bit_rate_index == 0x1f)
01143 quant_step_table = lossless_quant_d;
01144 else
01145 quant_step_table = lossy_quant_d;
01146
01147 for (k = base_channel; k < s->prim_channels; k++) {
01148 if (get_bits_left(&s->gb) < 0)
01149 return AVERROR_INVALIDDATA;
01150
01151 for (l = 0; l < s->vq_start_subband[k]; l++) {
01152 int m;
01153
01154
01155 int abits = s->bitalloc[k][l];
01156
01157 float quant_step_size = quant_step_table[abits];
01158
01159
01160
01161
01162
01163
01164 int sel = s->quant_index_huffman[k][abits];
01165
01166
01167
01168
01169 if (!abits) {
01170 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
01171 } else {
01172
01173 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
01174 float rscale = quant_step_size * s->scale_factor[k][l][sfi] *
01175 s->scalefactor_adj[k][sel];
01176
01177 if (abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table) {
01178 if (abits <= 7) {
01179
01180 int block_code1, block_code2, size, levels, err;
01181
01182 size = abits_sizes[abits - 1];
01183 levels = abits_levels[abits - 1];
01184
01185 block_code1 = get_bits(&s->gb, size);
01186 block_code2 = get_bits(&s->gb, size);
01187 err = decode_blockcodes(block_code1, block_code2,
01188 levels, block);
01189 if (err) {
01190 av_log(s->avctx, AV_LOG_ERROR,
01191 "ERROR: block code look-up failed\n");
01192 return AVERROR_INVALIDDATA;
01193 }
01194 } else {
01195
01196 for (m = 0; m < 8; m++)
01197 block[m] = get_sbits(&s->gb, abits - 3);
01198 }
01199 } else {
01200
01201 for (m = 0; m < 8; m++)
01202 block[m] = get_bitalloc(&s->gb,
01203 &dca_smpl_bitalloc[abits], sel);
01204 }
01205
01206 s->fmt_conv.int32_to_float_fmul_scalar(subband_samples[k][l],
01207 block, rscale, 8);
01208 }
01209
01210
01211
01212
01213 if (s->prediction_mode[k][l]) {
01214 int n;
01215 for (m = 0; m < 8; m++) {
01216 for (n = 1; n <= 4; n++)
01217 if (m >= n)
01218 subband_samples[k][l][m] +=
01219 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01220 subband_samples[k][l][m - n] / 8192);
01221 else if (s->predictor_history)
01222 subband_samples[k][l][m] +=
01223 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01224 s->subband_samples_hist[k][l][m - n + 4] / 8192);
01225 }
01226 }
01227 }
01228
01229
01230
01231
01232 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01233
01234
01235 int hfvq = s->high_freq_vq[k][l];
01236
01237 if (!s->debug_flag & 0x01) {
01238 av_log(s->avctx, AV_LOG_DEBUG,
01239 "Stream with high frequencies VQ coding\n");
01240 s->debug_flag |= 0x01;
01241 }
01242
01243 int8x8_fmul_int32(subband_samples[k][l],
01244 &high_freq_vq[hfvq][subsubframe * 8],
01245 s->scale_factor[k][l][0]);
01246 }
01247 }
01248
01249
01250 if (s->aspf || subsubframe == s->subsubframes[s->current_subframe] - 1) {
01251 if (0xFFFF == get_bits(&s->gb, 16)) {
01252 #ifdef TRACE
01253 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
01254 #endif
01255 } else {
01256 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
01257 }
01258 }
01259
01260
01261 for (k = base_channel; k < s->prim_channels; k++)
01262 for (l = 0; l < s->vq_start_subband[k]; l++)
01263 memcpy(s->subband_samples_hist[k][l],
01264 &subband_samples[k][l][4],
01265 4 * sizeof(subband_samples[0][0][0]));
01266
01267 return 0;
01268 }
01269
01270 static int dca_filter_channels(DCAContext *s, int block_index)
01271 {
01272 float (*subband_samples)[DCA_SUBBANDS][8] = s->subband_samples[block_index];
01273 int k;
01274
01275
01276 for (k = 0; k < s->prim_channels; k++) {
01277
01278
01279 qmf_32_subbands(s, k, subband_samples[k],
01280 &s->samples[256 * s->channel_order_tab[k]],
01281 M_SQRT1_2 * s->scale_bias );
01282 }
01283
01284
01285 if (s->avctx->request_channels == 2 && s->prim_channels > 2) {
01286 dca_downmix(s->samples, s->amode, s->downmix_coef, s->channel_order_tab);
01287 }
01288
01289
01290 if (s->output & DCA_LFE) {
01291 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
01292 s->lfe_data + 2 * s->lfe * (block_index + 4),
01293 &s->samples[256 * dca_lfe_index[s->amode]],
01294 (1.0 / 256.0) * s->scale_bias);
01295
01296 }
01297
01298 return 0;
01299 }
01300
01301
01302 static int dca_subframe_footer(DCAContext *s, int base_channel)
01303 {
01304 int aux_data_count = 0, i;
01305
01306
01307
01308
01309
01310
01311 if (!base_channel) {
01312 if (s->timestamp)
01313 skip_bits_long(&s->gb, 32);
01314
01315 if (s->aux_data)
01316 aux_data_count = get_bits(&s->gb, 6);
01317
01318 for (i = 0; i < aux_data_count; i++)
01319 get_bits(&s->gb, 8);
01320
01321 if (s->crc_present && (s->downmix || s->dynrange))
01322 get_bits(&s->gb, 16);
01323 }
01324
01325 return 0;
01326 }
01327
01334 static int dca_decode_block(DCAContext *s, int base_channel, int block_index)
01335 {
01336 int ret;
01337
01338
01339 if (s->current_subframe >= s->subframes) {
01340 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
01341 s->current_subframe, s->subframes);
01342 return AVERROR_INVALIDDATA;
01343 }
01344
01345 if (!s->current_subsubframe) {
01346 #ifdef TRACE
01347 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
01348 #endif
01349
01350 if ((ret = dca_subframe_header(s, base_channel, block_index)))
01351 return ret;
01352 }
01353
01354
01355 #ifdef TRACE
01356 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
01357 #endif
01358 if ((ret = dca_subsubframe(s, base_channel, block_index)))
01359 return ret;
01360
01361
01362 s->current_subsubframe++;
01363 if (s->current_subsubframe >= s->subsubframes[s->current_subframe]) {
01364 s->current_subsubframe = 0;
01365 s->current_subframe++;
01366 }
01367 if (s->current_subframe >= s->subframes) {
01368 #ifdef TRACE
01369 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
01370 #endif
01371
01372 if ((ret = dca_subframe_footer(s, base_channel)))
01373 return ret;
01374 }
01375
01376 return 0;
01377 }
01378
01382 static int dca_convert_bitstream(const uint8_t *src, int src_size, uint8_t *dst,
01383 int max_size)
01384 {
01385 uint32_t mrk;
01386 int i, tmp;
01387 const uint16_t *ssrc = (const uint16_t *) src;
01388 uint16_t *sdst = (uint16_t *) dst;
01389 PutBitContext pb;
01390
01391 if ((unsigned) src_size > (unsigned) max_size) {
01392
01393
01394 src_size = max_size;
01395 }
01396
01397 mrk = AV_RB32(src);
01398 switch (mrk) {
01399 case DCA_MARKER_RAW_BE:
01400 memcpy(dst, src, src_size);
01401 return src_size;
01402 case DCA_MARKER_RAW_LE:
01403 for (i = 0; i < (src_size + 1) >> 1; i++)
01404 *sdst++ = av_bswap16(*ssrc++);
01405 return src_size;
01406 case DCA_MARKER_14B_BE:
01407 case DCA_MARKER_14B_LE:
01408 init_put_bits(&pb, dst, max_size);
01409 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
01410 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
01411 put_bits(&pb, 14, tmp);
01412 }
01413 flush_put_bits(&pb);
01414 return (put_bits_count(&pb) + 7) >> 3;
01415 default:
01416 return AVERROR_INVALIDDATA;
01417 }
01418 }
01419
01423 static int dca_exss_mask2count(int mask)
01424 {
01425
01426 return av_popcount(mask) +
01427 av_popcount(mask & (DCA_EXSS_CENTER_LEFT_RIGHT |
01428 DCA_EXSS_FRONT_LEFT_RIGHT |
01429 DCA_EXSS_FRONT_HIGH_LEFT_RIGHT |
01430 DCA_EXSS_WIDE_LEFT_RIGHT |
01431 DCA_EXSS_SIDE_LEFT_RIGHT |
01432 DCA_EXSS_SIDE_HIGH_LEFT_RIGHT |
01433 DCA_EXSS_SIDE_REAR_LEFT_RIGHT |
01434 DCA_EXSS_REAR_LEFT_RIGHT |
01435 DCA_EXSS_REAR_HIGH_LEFT_RIGHT));
01436 }
01437
01441 static void dca_exss_skip_mix_coeffs(GetBitContext *gb, int channels, int out_ch)
01442 {
01443 int i;
01444
01445 for (i = 0; i < channels; i++) {
01446 int mix_map_mask = get_bits(gb, out_ch);
01447 int num_coeffs = av_popcount(mix_map_mask);
01448 skip_bits_long(gb, num_coeffs * 6);
01449 }
01450 }
01451
01455 static int dca_exss_parse_asset_header(DCAContext *s)
01456 {
01457 int header_pos = get_bits_count(&s->gb);
01458 int header_size;
01459 int channels;
01460 int embedded_stereo = 0;
01461 int embedded_6ch = 0;
01462 int drc_code_present;
01463 int extensions_mask;
01464 int i, j;
01465
01466 if (get_bits_left(&s->gb) < 16)
01467 return -1;
01468
01469
01470
01471
01472 header_size = get_bits(&s->gb, 9) + 1;
01473 skip_bits(&s->gb, 3);
01474
01475 if (s->static_fields) {
01476 if (get_bits1(&s->gb))
01477 skip_bits(&s->gb, 4);
01478 if (get_bits1(&s->gb))
01479 skip_bits_long(&s->gb, 24);
01480
01481 if (get_bits1(&s->gb)) {
01482
01483
01484 int text_length = get_bits(&s->gb, 10) + 1;
01485 if (get_bits_left(&s->gb) < text_length * 8)
01486 return -1;
01487 skip_bits_long(&s->gb, text_length * 8);
01488 }
01489
01490 skip_bits(&s->gb, 5);
01491 skip_bits(&s->gb, 4);
01492 channels = get_bits(&s->gb, 8) + 1;
01493
01494 if (get_bits1(&s->gb)) {
01495 int spkr_remap_sets;
01496 int spkr_mask_size = 16;
01497 int num_spkrs[7];
01498
01499 if (channels > 2)
01500 embedded_stereo = get_bits1(&s->gb);
01501 if (channels > 6)
01502 embedded_6ch = get_bits1(&s->gb);
01503
01504 if (get_bits1(&s->gb)) {
01505 spkr_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
01506 skip_bits(&s->gb, spkr_mask_size);
01507 }
01508
01509 spkr_remap_sets = get_bits(&s->gb, 3);
01510
01511 for (i = 0; i < spkr_remap_sets; i++) {
01512
01513 num_spkrs[i] = dca_exss_mask2count(get_bits(&s->gb, spkr_mask_size));
01514 }
01515
01516 for (i = 0; i < spkr_remap_sets; i++) {
01517 int num_dec_ch_remaps = get_bits(&s->gb, 5) + 1;
01518 if (get_bits_left(&s->gb) < 0)
01519 return -1;
01520
01521 for (j = 0; j < num_spkrs[i]; j++) {
01522 int remap_dec_ch_mask = get_bits_long(&s->gb, num_dec_ch_remaps);
01523 int num_dec_ch = av_popcount(remap_dec_ch_mask);
01524 skip_bits_long(&s->gb, num_dec_ch * 5);
01525 }
01526 }
01527
01528 } else {
01529 skip_bits(&s->gb, 3);
01530 }
01531 }
01532
01533 drc_code_present = get_bits1(&s->gb);
01534 if (drc_code_present)
01535 get_bits(&s->gb, 8);
01536
01537 if (get_bits1(&s->gb))
01538 skip_bits(&s->gb, 5);
01539
01540 if (drc_code_present && embedded_stereo)
01541 get_bits(&s->gb, 8);
01542
01543 if (s->mix_metadata && get_bits1(&s->gb)) {
01544 skip_bits(&s->gb, 1);
01545 skip_bits(&s->gb, 6);
01546
01547 if (get_bits(&s->gb, 2) != 3)
01548 skip_bits(&s->gb, 3);
01549 else
01550 skip_bits(&s->gb, 8);
01551
01552 if (get_bits1(&s->gb))
01553 for (i = 0; i < s->num_mix_configs; i++)
01554 skip_bits_long(&s->gb, s->mix_config_num_ch[i] * 6);
01555 else
01556 skip_bits_long(&s->gb, s->num_mix_configs * 6);
01557
01558 for (i = 0; i < s->num_mix_configs; i++) {
01559 if (get_bits_left(&s->gb) < 0)
01560 return -1;
01561 dca_exss_skip_mix_coeffs(&s->gb, channels, s->mix_config_num_ch[i]);
01562 if (embedded_6ch)
01563 dca_exss_skip_mix_coeffs(&s->gb, 6, s->mix_config_num_ch[i]);
01564 if (embedded_stereo)
01565 dca_exss_skip_mix_coeffs(&s->gb, 2, s->mix_config_num_ch[i]);
01566 }
01567 }
01568
01569 switch (get_bits(&s->gb, 2)) {
01570 case 0: extensions_mask = get_bits(&s->gb, 12); break;
01571 case 1: extensions_mask = DCA_EXT_EXSS_XLL; break;
01572 case 2: extensions_mask = DCA_EXT_EXSS_LBR; break;
01573 case 3: extensions_mask = 0; break;
01574 }
01575
01576
01577
01578 if (get_bits_left(&s->gb) < 0)
01579 return -1;
01580
01581 if (get_bits_count(&s->gb) - header_pos > header_size * 8) {
01582 av_log(s->avctx, AV_LOG_WARNING, "Asset header size mismatch.\n");
01583 return -1;
01584 }
01585 skip_bits_long(&s->gb, header_pos + header_size * 8 - get_bits_count(&s->gb));
01586
01587 if (extensions_mask & DCA_EXT_EXSS_XLL)
01588 s->profile = FF_PROFILE_DTS_HD_MA;
01589 else if (extensions_mask & (DCA_EXT_EXSS_XBR | DCA_EXT_EXSS_X96 |
01590 DCA_EXT_EXSS_XXCH))
01591 s->profile = FF_PROFILE_DTS_HD_HRA;
01592
01593 if (!(extensions_mask & DCA_EXT_CORE))
01594 av_log(s->avctx, AV_LOG_WARNING, "DTS core detection mismatch.\n");
01595 if ((extensions_mask & DCA_CORE_EXTS) != s->core_ext_mask)
01596 av_log(s->avctx, AV_LOG_WARNING,
01597 "DTS extensions detection mismatch (%d, %d)\n",
01598 extensions_mask & DCA_CORE_EXTS, s->core_ext_mask);
01599
01600 return 0;
01601 }
01602
01606 static void dca_exss_parse_header(DCAContext *s)
01607 {
01608 int ss_index;
01609 int blownup;
01610 int num_audiop = 1;
01611 int num_assets = 1;
01612 int active_ss_mask[8];
01613 int i, j;
01614
01615 if (get_bits_left(&s->gb) < 52)
01616 return;
01617
01618 skip_bits(&s->gb, 8);
01619 ss_index = get_bits(&s->gb, 2);
01620
01621 blownup = get_bits1(&s->gb);
01622 skip_bits(&s->gb, 8 + 4 * blownup);
01623 skip_bits(&s->gb, 16 + 4 * blownup);
01624
01625 s->static_fields = get_bits1(&s->gb);
01626 if (s->static_fields) {
01627 skip_bits(&s->gb, 2);
01628 skip_bits(&s->gb, 3);
01629
01630 if (get_bits1(&s->gb))
01631 skip_bits_long(&s->gb, 36);
01632
01633
01634
01635
01636 num_audiop = get_bits(&s->gb, 3) + 1;
01637 if (num_audiop > 1) {
01638 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio presentations.");
01639
01640 return;
01641 }
01642
01643 num_assets = get_bits(&s->gb, 3) + 1;
01644 if (num_assets > 1) {
01645 av_log_ask_for_sample(s->avctx, "Multiple DTS-HD audio assets.");
01646
01647 return;
01648 }
01649
01650 for (i = 0; i < num_audiop; i++)
01651 active_ss_mask[i] = get_bits(&s->gb, ss_index + 1);
01652
01653 for (i = 0; i < num_audiop; i++)
01654 for (j = 0; j <= ss_index; j++)
01655 if (active_ss_mask[i] & (1 << j))
01656 skip_bits(&s->gb, 8);
01657
01658 s->mix_metadata = get_bits1(&s->gb);
01659 if (s->mix_metadata) {
01660 int mix_out_mask_size;
01661
01662 skip_bits(&s->gb, 2);
01663 mix_out_mask_size = (get_bits(&s->gb, 2) + 1) << 2;
01664 s->num_mix_configs = get_bits(&s->gb, 2) + 1;
01665
01666 for (i = 0; i < s->num_mix_configs; i++) {
01667 int mix_out_mask = get_bits(&s->gb, mix_out_mask_size);
01668 s->mix_config_num_ch[i] = dca_exss_mask2count(mix_out_mask);
01669 }
01670 }
01671 }
01672
01673 for (i = 0; i < num_assets; i++)
01674 skip_bits_long(&s->gb, 16 + 4 * blownup);
01675
01676 for (i = 0; i < num_assets; i++) {
01677 if (dca_exss_parse_asset_header(s))
01678 return;
01679 }
01680
01681
01682
01683 }
01684
01689 static int dca_decode_frame(AVCodecContext *avctx, void *data,
01690 int *got_frame_ptr, AVPacket *avpkt)
01691 {
01692 const uint8_t *buf = avpkt->data;
01693 int buf_size = avpkt->size;
01694
01695 int lfe_samples;
01696 int num_core_channels = 0;
01697 int i, ret;
01698 float *samples_flt;
01699 int16_t *samples_s16;
01700 DCAContext *s = avctx->priv_data;
01701 int channels;
01702 int core_ss_end;
01703
01704
01705 s->xch_present = 0;
01706
01707 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer,
01708 DCA_MAX_FRAME_SIZE + DCA_MAX_EXSS_HEADER_SIZE);
01709 if (s->dca_buffer_size == AVERROR_INVALIDDATA) {
01710 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
01711 return AVERROR_INVALIDDATA;
01712 }
01713
01714 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
01715 if ((ret = dca_parse_frame_header(s)) < 0) {
01716
01717 return ret;
01718 }
01719
01720 avctx->sample_rate = s->sample_rate;
01721 avctx->bit_rate = s->bit_rate;
01722 avctx->frame_size = s->sample_blocks * 32;
01723
01724 s->profile = FF_PROFILE_DTS;
01725
01726 for (i = 0; i < (s->sample_blocks / 8); i++) {
01727 if ((ret = dca_decode_block(s, 0, i))) {
01728 av_log(avctx, AV_LOG_ERROR, "error decoding block\n");
01729 return ret;
01730 }
01731 }
01732
01733
01734 num_core_channels = s->prim_channels;
01735
01736 if (s->ext_coding)
01737 s->core_ext_mask = dca_ext_audio_descr_mask[s->ext_descr];
01738 else
01739 s->core_ext_mask = 0;
01740
01741 core_ss_end = FFMIN(s->frame_size, s->dca_buffer_size) * 8;
01742
01743
01744
01745 if (s->core_ext_mask < 0 || s->core_ext_mask & DCA_EXT_XCH) {
01746
01747
01748
01749 s->core_ext_mask = FFMAX(s->core_ext_mask, 0);
01750
01751
01752 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01753
01754 while (core_ss_end - get_bits_count(&s->gb) >= 32) {
01755 uint32_t bits = get_bits_long(&s->gb, 32);
01756
01757 switch (bits) {
01758 case 0x5a5a5a5a: {
01759 int ext_amode, xch_fsize;
01760
01761 s->xch_base_channel = s->prim_channels;
01762
01763
01764 xch_fsize = show_bits(&s->gb, 10);
01765 if ((s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize) &&
01766 (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + xch_fsize + 1))
01767 continue;
01768
01769
01770 skip_bits(&s->gb, 10);
01771
01772 s->core_ext_mask |= DCA_EXT_XCH;
01773
01774
01775
01776 if ((ext_amode = get_bits(&s->gb, 4)) != 1) {
01777 av_log(avctx, AV_LOG_ERROR, "XCh extension amode %d not"
01778 " supported!\n", ext_amode);
01779 continue;
01780 }
01781
01782
01783 dca_parse_audio_coding_header(s, s->xch_base_channel);
01784
01785 for (i = 0; i < (s->sample_blocks / 8); i++)
01786 if ((ret = dca_decode_block(s, s->xch_base_channel, i))) {
01787 av_log(avctx, AV_LOG_ERROR, "error decoding XCh extension\n");
01788 continue;
01789 }
01790
01791 s->xch_present = 1;
01792 break;
01793 }
01794 case 0x47004a03:
01795
01796
01797
01798 s->core_ext_mask |= DCA_EXT_XXCH;
01799 break;
01800
01801 case 0x1d95f262: {
01802 int fsize96 = show_bits(&s->gb, 12) + 1;
01803 if (s->frame_size != (get_bits_count(&s->gb) >> 3) - 4 + fsize96)
01804 continue;
01805
01806 av_log(avctx, AV_LOG_DEBUG, "X96 extension found at %d bits\n",
01807 get_bits_count(&s->gb));
01808 skip_bits(&s->gb, 12);
01809 av_log(avctx, AV_LOG_DEBUG, "FSIZE96 = %d bytes\n", fsize96);
01810 av_log(avctx, AV_LOG_DEBUG, "REVNO = %d\n", get_bits(&s->gb, 4));
01811
01812 s->core_ext_mask |= DCA_EXT_X96;
01813 break;
01814 }
01815 }
01816
01817 skip_bits_long(&s->gb, (-get_bits_count(&s->gb)) & 31);
01818 }
01819 } else {
01820
01821 skip_bits_long(&s->gb, core_ss_end - get_bits_count(&s->gb));
01822 }
01823
01824 if (s->core_ext_mask & DCA_EXT_X96)
01825 s->profile = FF_PROFILE_DTS_96_24;
01826 else if (s->core_ext_mask & (DCA_EXT_XCH | DCA_EXT_XXCH))
01827 s->profile = FF_PROFILE_DTS_ES;
01828
01829
01830 if (s->dca_buffer_size - s->frame_size > 32 &&
01831 get_bits_long(&s->gb, 32) == DCA_HD_MARKER)
01832 dca_exss_parse_header(s);
01833
01834 avctx->profile = s->profile;
01835
01836 channels = s->prim_channels + !!s->lfe;
01837
01838 if (s->amode < 16) {
01839 avctx->channel_layout = dca_core_channel_layout[s->amode];
01840
01841 if (s->xch_present && (!avctx->request_channels ||
01842 avctx->request_channels > num_core_channels + !!s->lfe)) {
01843 avctx->channel_layout |= AV_CH_BACK_CENTER;
01844 if (s->lfe) {
01845 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01846 s->channel_order_tab = dca_channel_reorder_lfe_xch[s->amode];
01847 } else {
01848 s->channel_order_tab = dca_channel_reorder_nolfe_xch[s->amode];
01849 }
01850 } else {
01851 channels = num_core_channels + !!s->lfe;
01852 s->xch_present = 0;
01853 if (s->lfe) {
01854 avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
01855 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
01856 } else
01857 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
01858 }
01859
01860 if (channels > !!s->lfe &&
01861 s->channel_order_tab[channels - 1 - !!s->lfe] < 0)
01862 return AVERROR_INVALIDDATA;
01863
01864 if (avctx->request_channels == 2 && s->prim_channels > 2) {
01865 channels = 2;
01866 s->output = DCA_STEREO;
01867 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
01868 }
01869 } else {
01870 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n", s->amode);
01871 return AVERROR_INVALIDDATA;
01872 }
01873
01874
01875
01876
01877
01878
01879
01880 if (s->is_channels_set == 0) {
01881 s->is_channels_set = 1;
01882 avctx->channels = channels;
01883 }
01884 if (avctx->channels != channels) {
01885 av_log(avctx, AV_LOG_ERROR, "DCA decoder does not support number of "
01886 "channels changing in stream. Skipping frame.\n");
01887 return AVERROR_PATCHWELCOME;
01888 }
01889
01890
01891 s->frame.nb_samples = 256 * (s->sample_blocks / 8);
01892 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
01893 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01894 return ret;
01895 }
01896 samples_flt = (float *) s->frame.data[0];
01897 samples_s16 = (int16_t *) s->frame.data[0];
01898
01899
01900 for (i = 0; i < (s->sample_blocks / 8); i++) {
01901 dca_filter_channels(s, i);
01902
01903
01904
01905 if ((s->source_pcm_res & 1) && s->xch_present) {
01906 float *back_chan = s->samples + s->channel_order_tab[s->xch_base_channel] * 256;
01907 float *lt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 2] * 256;
01908 float *rt_chan = s->samples + s->channel_order_tab[s->xch_base_channel - 1] * 256;
01909 s->dsp.vector_fmac_scalar(lt_chan, back_chan, -M_SQRT1_2, 256);
01910 s->dsp.vector_fmac_scalar(rt_chan, back_chan, -M_SQRT1_2, 256);
01911 }
01912
01913 if (avctx->sample_fmt == AV_SAMPLE_FMT_FLT) {
01914 s->fmt_conv.float_interleave(samples_flt, s->samples_chanptr, 256,
01915 channels);
01916 samples_flt += 256 * channels;
01917 } else {
01918 s->fmt_conv.float_to_int16_interleave(samples_s16,
01919 s->samples_chanptr, 256,
01920 channels);
01921 samples_s16 += 256 * channels;
01922 }
01923 }
01924
01925
01926 lfe_samples = 2 * s->lfe * (s->sample_blocks / 8);
01927 for (i = 0; i < 2 * s->lfe * 4; i++)
01928 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
01929
01930 *got_frame_ptr = 1;
01931 *(AVFrame *) data = s->frame;
01932
01933 return buf_size;
01934 }
01935
01936
01937
01944 static av_cold int dca_decode_init(AVCodecContext *avctx)
01945 {
01946 DCAContext *s = avctx->priv_data;
01947 int i;
01948
01949 s->avctx = avctx;
01950 dca_init_vlcs();
01951
01952 dsputil_init(&s->dsp, avctx);
01953 ff_mdct_init(&s->imdct, 6, 1, 1.0);
01954 ff_synth_filter_init(&s->synth);
01955 ff_dcadsp_init(&s->dcadsp);
01956 ff_fmt_convert_init(&s->fmt_conv, avctx);
01957
01958 for (i = 0; i < DCA_PRIM_CHANNELS_MAX + 1; i++)
01959 s->samples_chanptr[i] = s->samples + i * 256;
01960
01961 if (avctx->request_sample_fmt == AV_SAMPLE_FMT_FLT) {
01962 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;
01963 s->scale_bias = 1.0 / 32768.0;
01964 } else {
01965 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01966 s->scale_bias = 1.0;
01967 }
01968
01969
01970 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
01971 avctx->request_channels == 2) {
01972 avctx->channels = avctx->request_channels;
01973 }
01974
01975 avcodec_get_frame_defaults(&s->frame);
01976 avctx->coded_frame = &s->frame;
01977
01978 return 0;
01979 }
01980
01981 static av_cold int dca_decode_end(AVCodecContext *avctx)
01982 {
01983 DCAContext *s = avctx->priv_data;
01984 ff_mdct_end(&s->imdct);
01985 return 0;
01986 }
01987
01988 static const AVProfile profiles[] = {
01989 { FF_PROFILE_DTS, "DTS" },
01990 { FF_PROFILE_DTS_ES, "DTS-ES" },
01991 { FF_PROFILE_DTS_96_24, "DTS 96/24" },
01992 { FF_PROFILE_DTS_HD_HRA, "DTS-HD HRA" },
01993 { FF_PROFILE_DTS_HD_MA, "DTS-HD MA" },
01994 { FF_PROFILE_UNKNOWN },
01995 };
01996
01997 AVCodec ff_dca_decoder = {
01998 .name = "dca",
01999 .type = AVMEDIA_TYPE_AUDIO,
02000 .id = CODEC_ID_DTS,
02001 .priv_data_size = sizeof(DCAContext),
02002 .init = dca_decode_init,
02003 .decode = dca_decode_frame,
02004 .close = dca_decode_end,
02005 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
02006 .capabilities = CODEC_CAP_CHANNEL_CONF | CODEC_CAP_DR1,
02007 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
02008 AV_SAMPLE_FMT_S16,
02009 AV_SAMPLE_FMT_NONE },
02010 .profiles = NULL_IF_CONFIG_SMALL(profiles),
02011 };