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