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