00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00029 #include <math.h>
00030 #include <stddef.h>
00031 #include <stdio.h>
00032
00033 #include "libavutil/intmath.h"
00034 #include "libavutil/intreadwrite.h"
00035 #include "avcodec.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
00046
00047
00048 #define DCA_PRIM_CHANNELS_MAX (5)
00049 #define DCA_SUBBANDS (32)
00050 #define DCA_ABITS_MAX (32)
00051 #define DCA_SUBSUBFAMES_MAX (4)
00052 #define DCA_LFE_MAX (3)
00053
00054 enum DCAMode {
00055 DCA_MONO = 0,
00056 DCA_CHANNEL,
00057 DCA_STEREO,
00058 DCA_STEREO_SUMDIFF,
00059 DCA_STEREO_TOTAL,
00060 DCA_3F,
00061 DCA_2F1R,
00062 DCA_3F1R,
00063 DCA_2F2R,
00064 DCA_3F2R,
00065 DCA_4F2R
00066 };
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078 static const int64_t dca_core_channel_layout[] = {
00079 CH_FRONT_CENTER,
00080 CH_LAYOUT_STEREO,
00081 CH_LAYOUT_STEREO,
00082 CH_LAYOUT_STEREO,
00083 CH_LAYOUT_STEREO,
00084 CH_LAYOUT_STEREO|CH_FRONT_CENTER,
00085 CH_LAYOUT_STEREO|CH_BACK_CENTER,
00086 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_BACK_CENTER,
00087 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,
00088 CH_LAYOUT_STEREO|CH_FRONT_CENTER|CH_SIDE_LEFT|CH_SIDE_RIGHT,
00089 CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER,
00090 CH_LAYOUT_STEREO|CH_BACK_LEFT|CH_BACK_RIGHT|CH_FRONT_CENTER|CH_BACK_CENTER,
00091 CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_FRONT_LEFT_OF_CENTER|CH_BACK_CENTER|CH_BACK_LEFT|CH_BACK_RIGHT,
00092 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT,
00093 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_SIDE_RIGHT|CH_BACK_LEFT|CH_BACK_RIGHT,
00094 CH_FRONT_LEFT_OF_CENTER|CH_FRONT_CENTER|CH_FRONT_RIGHT_OF_CENTER|CH_LAYOUT_STEREO|CH_SIDE_LEFT|CH_BACK_CENTER|CH_SIDE_RIGHT,
00095 };
00096
00097 static const int8_t dca_lfe_index[] = {
00098 1,2,2,2,2,3,2,3,2,3,2,3,1,3,2,3
00099 };
00100
00101 static const int8_t dca_channel_reorder_lfe[][8] = {
00102 { 0, -1, -1, -1, -1, -1, -1, -1},
00103 { 0, 1, -1, -1, -1, -1, -1, -1},
00104 { 0, 1, -1, -1, -1, -1, -1, -1},
00105 { 0, 1, -1, -1, -1, -1, -1, -1},
00106 { 0, 1, -1, -1, -1, -1, -1, -1},
00107 { 2, 0, 1, -1, -1, -1, -1, -1},
00108 { 0, 1, 3, -1, -1, -1, -1, -1},
00109 { 2, 0, 1, 4, -1, -1, -1, -1},
00110 { 0, 1, 3, 4, -1, -1, -1, -1},
00111 { 2, 0, 1, 4, 5, -1, -1, -1},
00112 { 3, 4, 0, 1, 5, 6, -1, -1},
00113 { 2, 0, 1, 4, 5, 6, -1, -1},
00114 { 0, 6, 4, 5, 2, 3, -1, -1},
00115 { 4, 2, 5, 0, 1, 6, 7, -1},
00116 { 5, 6, 0, 1, 7, 3, 8, 4},
00117 { 4, 2, 5, 0, 1, 6, 8, 7},
00118 };
00119
00120 static const int8_t dca_channel_reorder_nolfe[][8] = {
00121 { 0, -1, -1, -1, -1, -1, -1, -1},
00122 { 0, 1, -1, -1, -1, -1, -1, -1},
00123 { 0, 1, -1, -1, -1, -1, -1, -1},
00124 { 0, 1, -1, -1, -1, -1, -1, -1},
00125 { 0, 1, -1, -1, -1, -1, -1, -1},
00126 { 2, 0, 1, -1, -1, -1, -1, -1},
00127 { 0, 1, 2, -1, -1, -1, -1, -1},
00128 { 2, 0, 1, 3, -1, -1, -1, -1},
00129 { 0, 1, 2, 3, -1, -1, -1, -1},
00130 { 2, 0, 1, 3, 4, -1, -1, -1},
00131 { 2, 3, 0, 1, 4, 5, -1, -1},
00132 { 2, 0, 1, 3, 4, 5, -1, -1},
00133 { 0, 5, 3, 4, 1, 2, -1, -1},
00134 { 3, 2, 4, 0, 1, 5, 6, -1},
00135 { 4, 5, 0, 1, 6, 2, 7, 3},
00136 { 3, 2, 4, 0, 1, 5, 7, 6},
00137 };
00138
00139
00140 #define DCA_DOLBY 101
00141
00142 #define DCA_CHANNEL_BITS 6
00143 #define DCA_CHANNEL_MASK 0x3F
00144
00145 #define DCA_LFE 0x80
00146
00147 #define HEADER_SIZE 14
00148
00149 #define DCA_MAX_FRAME_SIZE 16384
00150
00152 typedef struct {
00153 int offset;
00154 int maxbits[8];
00155 int wrap;
00156 VLC vlc[8];
00157 } BitAlloc;
00158
00159 static BitAlloc dca_bitalloc_index;
00160 static BitAlloc dca_tmode;
00161 static BitAlloc dca_scalefactor;
00162 static BitAlloc dca_smpl_bitalloc[11];
00163
00164 static av_always_inline int get_bitalloc(GetBitContext *gb, BitAlloc *ba, int idx)
00165 {
00166 return get_vlc2(gb, ba->vlc[idx].table, ba->vlc[idx].bits, ba->wrap) + ba->offset;
00167 }
00168
00169 typedef struct {
00170 AVCodecContext *avctx;
00171
00172 int frame_type;
00173 int samples_deficit;
00174 int crc_present;
00175 int sample_blocks;
00176 int frame_size;
00177 int amode;
00178 int sample_rate;
00179 int bit_rate;
00180 int bit_rate_index;
00181
00182 int downmix;
00183 int dynrange;
00184 int timestamp;
00185 int aux_data;
00186 int hdcd;
00187 int ext_descr;
00188 int ext_coding;
00189 int aspf;
00190 int lfe;
00191 int predictor_history;
00192 int header_crc;
00193 int multirate_inter;
00194 int version;
00195 int copy_history;
00196 int source_pcm_res;
00197 int front_sum;
00198 int surround_sum;
00199 int dialog_norm;
00200
00201
00202 int subframes;
00203 int total_channels;
00204 int prim_channels;
00205 int subband_activity[DCA_PRIM_CHANNELS_MAX];
00206 int vq_start_subband[DCA_PRIM_CHANNELS_MAX];
00207 int joint_intensity[DCA_PRIM_CHANNELS_MAX];
00208 int transient_huffman[DCA_PRIM_CHANNELS_MAX];
00209 int scalefactor_huffman[DCA_PRIM_CHANNELS_MAX];
00210 int bitalloc_huffman[DCA_PRIM_CHANNELS_MAX];
00211 int quant_index_huffman[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];
00212 float scalefactor_adj[DCA_PRIM_CHANNELS_MAX][DCA_ABITS_MAX];
00213
00214
00215 int subsubframes;
00216 int partial_samples;
00217 int prediction_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00218 int prediction_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00219 int bitalloc[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00220 int transition_mode[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00221 int scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][2];
00222 int joint_huff[DCA_PRIM_CHANNELS_MAX];
00223 int joint_scale_factor[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00224 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2];
00225 int dynrange_coef;
00226
00227 int high_freq_vq[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS];
00228
00229 float lfe_data[2 * DCA_SUBSUBFAMES_MAX * DCA_LFE_MAX *
00230 2 ];
00231 int lfe_scale_factor;
00232
00233
00234 float subband_samples_hist[DCA_PRIM_CHANNELS_MAX][DCA_SUBBANDS][4];
00235 DECLARE_ALIGNED(16, float, subband_fir_hist)[DCA_PRIM_CHANNELS_MAX][512];
00236 DECLARE_ALIGNED(16, float, subband_fir_noidea)[DCA_PRIM_CHANNELS_MAX][32];
00237 int hist_index[DCA_PRIM_CHANNELS_MAX];
00238 DECLARE_ALIGNED(16, float, raXin)[32];
00239
00240 int output;
00241 float add_bias;
00242 float scale_bias;
00243
00244 DECLARE_ALIGNED(16, float, samples)[1536];
00245 const float *samples_chanptr[6];
00246
00247 uint8_t dca_buffer[DCA_MAX_FRAME_SIZE];
00248 int dca_buffer_size;
00249
00250 const int8_t* channel_order_tab;
00251 GetBitContext gb;
00252
00253 int current_subframe;
00254 int current_subsubframe;
00255
00256 int debug_flag;
00257 DSPContext dsp;
00258 FFTContext imdct;
00259 SynthFilterContext synth;
00260 DCADSPContext dcadsp;
00261 } DCAContext;
00262
00263 static const uint16_t dca_vlc_offs[] = {
00264 0, 512, 640, 768, 1282, 1794, 2436, 3080, 3770, 4454, 5364,
00265 5372, 5380, 5388, 5392, 5396, 5412, 5420, 5428, 5460, 5492, 5508,
00266 5572, 5604, 5668, 5796, 5860, 5892, 6412, 6668, 6796, 7308, 7564,
00267 7820, 8076, 8620, 9132, 9388, 9910, 10166, 10680, 11196, 11726, 12240,
00268 12752, 13298, 13810, 14326, 14840, 15500, 16022, 16540, 17158, 17678, 18264,
00269 18796, 19352, 19926, 20468, 21472, 22398, 23014, 23622,
00270 };
00271
00272 static av_cold void dca_init_vlcs(void)
00273 {
00274 static int vlcs_initialized = 0;
00275 int i, j, c = 14;
00276 static VLC_TYPE dca_table[23622][2];
00277
00278 if (vlcs_initialized)
00279 return;
00280
00281 dca_bitalloc_index.offset = 1;
00282 dca_bitalloc_index.wrap = 2;
00283 for (i = 0; i < 5; i++) {
00284 dca_bitalloc_index.vlc[i].table = &dca_table[dca_vlc_offs[i]];
00285 dca_bitalloc_index.vlc[i].table_allocated = dca_vlc_offs[i + 1] - dca_vlc_offs[i];
00286 init_vlc(&dca_bitalloc_index.vlc[i], bitalloc_12_vlc_bits[i], 12,
00287 bitalloc_12_bits[i], 1, 1,
00288 bitalloc_12_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00289 }
00290 dca_scalefactor.offset = -64;
00291 dca_scalefactor.wrap = 2;
00292 for (i = 0; i < 5; i++) {
00293 dca_scalefactor.vlc[i].table = &dca_table[dca_vlc_offs[i + 5]];
00294 dca_scalefactor.vlc[i].table_allocated = dca_vlc_offs[i + 6] - dca_vlc_offs[i + 5];
00295 init_vlc(&dca_scalefactor.vlc[i], SCALES_VLC_BITS, 129,
00296 scales_bits[i], 1, 1,
00297 scales_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00298 }
00299 dca_tmode.offset = 0;
00300 dca_tmode.wrap = 1;
00301 for (i = 0; i < 4; i++) {
00302 dca_tmode.vlc[i].table = &dca_table[dca_vlc_offs[i + 10]];
00303 dca_tmode.vlc[i].table_allocated = dca_vlc_offs[i + 11] - dca_vlc_offs[i + 10];
00304 init_vlc(&dca_tmode.vlc[i], tmode_vlc_bits[i], 4,
00305 tmode_bits[i], 1, 1,
00306 tmode_codes[i], 2, 2, INIT_VLC_USE_NEW_STATIC);
00307 }
00308
00309 for(i = 0; i < 10; i++)
00310 for(j = 0; j < 7; j++){
00311 if(!bitalloc_codes[i][j]) break;
00312 dca_smpl_bitalloc[i+1].offset = bitalloc_offsets[i];
00313 dca_smpl_bitalloc[i+1].wrap = 1 + (j > 4);
00314 dca_smpl_bitalloc[i+1].vlc[j].table = &dca_table[dca_vlc_offs[c]];
00315 dca_smpl_bitalloc[i+1].vlc[j].table_allocated = dca_vlc_offs[c + 1] - dca_vlc_offs[c];
00316 init_vlc(&dca_smpl_bitalloc[i+1].vlc[j], bitalloc_maxbits[i][j],
00317 bitalloc_sizes[i],
00318 bitalloc_bits[i][j], 1, 1,
00319 bitalloc_codes[i][j], 2, 2, INIT_VLC_USE_NEW_STATIC);
00320 c++;
00321 }
00322 vlcs_initialized = 1;
00323 }
00324
00325 static inline void get_array(GetBitContext *gb, int *dst, int len, int bits)
00326 {
00327 while(len--)
00328 *dst++ = get_bits(gb, bits);
00329 }
00330
00331 static int dca_parse_frame_header(DCAContext * s)
00332 {
00333 int i, j;
00334 static const float adj_table[4] = { 1.0, 1.1250, 1.2500, 1.4375 };
00335 static const int bitlen[11] = { 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3 };
00336 static const int thr[11] = { 0, 1, 3, 3, 3, 3, 7, 7, 7, 7, 7 };
00337
00338 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
00339
00340
00341 get_bits(&s->gb, 32);
00342
00343
00344 s->frame_type = get_bits(&s->gb, 1);
00345 s->samples_deficit = get_bits(&s->gb, 5) + 1;
00346 s->crc_present = get_bits(&s->gb, 1);
00347 s->sample_blocks = get_bits(&s->gb, 7) + 1;
00348 s->frame_size = get_bits(&s->gb, 14) + 1;
00349 if (s->frame_size < 95)
00350 return -1;
00351 s->amode = get_bits(&s->gb, 6);
00352 s->sample_rate = dca_sample_rates[get_bits(&s->gb, 4)];
00353 if (!s->sample_rate)
00354 return -1;
00355 s->bit_rate_index = get_bits(&s->gb, 5);
00356 s->bit_rate = dca_bit_rates[s->bit_rate_index];
00357 if (!s->bit_rate)
00358 return -1;
00359
00360 s->downmix = get_bits(&s->gb, 1);
00361 s->dynrange = get_bits(&s->gb, 1);
00362 s->timestamp = get_bits(&s->gb, 1);
00363 s->aux_data = get_bits(&s->gb, 1);
00364 s->hdcd = get_bits(&s->gb, 1);
00365 s->ext_descr = get_bits(&s->gb, 3);
00366 s->ext_coding = get_bits(&s->gb, 1);
00367 s->aspf = get_bits(&s->gb, 1);
00368 s->lfe = get_bits(&s->gb, 2);
00369 s->predictor_history = get_bits(&s->gb, 1);
00370
00371
00372 if (s->crc_present)
00373 s->header_crc = get_bits(&s->gb, 16);
00374
00375 s->multirate_inter = get_bits(&s->gb, 1);
00376 s->version = get_bits(&s->gb, 4);
00377 s->copy_history = get_bits(&s->gb, 2);
00378 s->source_pcm_res = get_bits(&s->gb, 3);
00379 s->front_sum = get_bits(&s->gb, 1);
00380 s->surround_sum = get_bits(&s->gb, 1);
00381 s->dialog_norm = get_bits(&s->gb, 4);
00382
00383
00384 s->output = s->amode;
00385 if(s->lfe) s->output |= DCA_LFE;
00386
00387 #ifdef TRACE
00388 av_log(s->avctx, AV_LOG_DEBUG, "frame type: %i\n", s->frame_type);
00389 av_log(s->avctx, AV_LOG_DEBUG, "samples deficit: %i\n", s->samples_deficit);
00390 av_log(s->avctx, AV_LOG_DEBUG, "crc present: %i\n", s->crc_present);
00391 av_log(s->avctx, AV_LOG_DEBUG, "sample blocks: %i (%i samples)\n",
00392 s->sample_blocks, s->sample_blocks * 32);
00393 av_log(s->avctx, AV_LOG_DEBUG, "frame size: %i bytes\n", s->frame_size);
00394 av_log(s->avctx, AV_LOG_DEBUG, "amode: %i (%i channels)\n",
00395 s->amode, dca_channels[s->amode]);
00396 av_log(s->avctx, AV_LOG_DEBUG, "sample rate: %i Hz\n",
00397 s->sample_rate);
00398 av_log(s->avctx, AV_LOG_DEBUG, "bit rate: %i bits/s\n",
00399 s->bit_rate);
00400 av_log(s->avctx, AV_LOG_DEBUG, "downmix: %i\n", s->downmix);
00401 av_log(s->avctx, AV_LOG_DEBUG, "dynrange: %i\n", s->dynrange);
00402 av_log(s->avctx, AV_LOG_DEBUG, "timestamp: %i\n", s->timestamp);
00403 av_log(s->avctx, AV_LOG_DEBUG, "aux_data: %i\n", s->aux_data);
00404 av_log(s->avctx, AV_LOG_DEBUG, "hdcd: %i\n", s->hdcd);
00405 av_log(s->avctx, AV_LOG_DEBUG, "ext descr: %i\n", s->ext_descr);
00406 av_log(s->avctx, AV_LOG_DEBUG, "ext coding: %i\n", s->ext_coding);
00407 av_log(s->avctx, AV_LOG_DEBUG, "aspf: %i\n", s->aspf);
00408 av_log(s->avctx, AV_LOG_DEBUG, "lfe: %i\n", s->lfe);
00409 av_log(s->avctx, AV_LOG_DEBUG, "predictor history: %i\n",
00410 s->predictor_history);
00411 av_log(s->avctx, AV_LOG_DEBUG, "header crc: %i\n", s->header_crc);
00412 av_log(s->avctx, AV_LOG_DEBUG, "multirate inter: %i\n",
00413 s->multirate_inter);
00414 av_log(s->avctx, AV_LOG_DEBUG, "version number: %i\n", s->version);
00415 av_log(s->avctx, AV_LOG_DEBUG, "copy history: %i\n", s->copy_history);
00416 av_log(s->avctx, AV_LOG_DEBUG,
00417 "source pcm resolution: %i (%i bits/sample)\n",
00418 s->source_pcm_res, dca_bits_per_sample[s->source_pcm_res]);
00419 av_log(s->avctx, AV_LOG_DEBUG, "front sum: %i\n", s->front_sum);
00420 av_log(s->avctx, AV_LOG_DEBUG, "surround sum: %i\n", s->surround_sum);
00421 av_log(s->avctx, AV_LOG_DEBUG, "dialog norm: %i\n", s->dialog_norm);
00422 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00423 #endif
00424
00425
00426 s->subframes = get_bits(&s->gb, 4) + 1;
00427 s->total_channels = get_bits(&s->gb, 3) + 1;
00428 s->prim_channels = s->total_channels;
00429 if (s->prim_channels > DCA_PRIM_CHANNELS_MAX)
00430 s->prim_channels = DCA_PRIM_CHANNELS_MAX;
00431
00432
00433 for (i = 0; i < s->prim_channels; i++) {
00434 s->subband_activity[i] = get_bits(&s->gb, 5) + 2;
00435 if (s->subband_activity[i] > DCA_SUBBANDS)
00436 s->subband_activity[i] = DCA_SUBBANDS;
00437 }
00438 for (i = 0; i < s->prim_channels; i++) {
00439 s->vq_start_subband[i] = get_bits(&s->gb, 5) + 1;
00440 if (s->vq_start_subband[i] > DCA_SUBBANDS)
00441 s->vq_start_subband[i] = DCA_SUBBANDS;
00442 }
00443 get_array(&s->gb, s->joint_intensity, s->prim_channels, 3);
00444 get_array(&s->gb, s->transient_huffman, s->prim_channels, 2);
00445 get_array(&s->gb, s->scalefactor_huffman, s->prim_channels, 3);
00446 get_array(&s->gb, s->bitalloc_huffman, s->prim_channels, 3);
00447
00448
00449 memset(s->quant_index_huffman, 0, sizeof(s->quant_index_huffman));
00450 for (j = 1; j < 11; j++)
00451 for (i = 0; i < s->prim_channels; i++)
00452 s->quant_index_huffman[i][j] = get_bits(&s->gb, bitlen[j]);
00453
00454
00455 for (j = 0; j < 11; j++)
00456 for (i = 0; i < s->prim_channels; i++)
00457 s->scalefactor_adj[i][j] = 1;
00458
00459 for (j = 1; j < 11; j++)
00460 for (i = 0; i < s->prim_channels; i++)
00461 if (s->quant_index_huffman[i][j] < thr[j])
00462 s->scalefactor_adj[i][j] = adj_table[get_bits(&s->gb, 2)];
00463
00464 if (s->crc_present) {
00465
00466 get_bits(&s->gb, 16);
00467 }
00468
00469 s->current_subframe = 0;
00470 s->current_subsubframe = 0;
00471
00472 #ifdef TRACE
00473 av_log(s->avctx, AV_LOG_DEBUG, "subframes: %i\n", s->subframes);
00474 av_log(s->avctx, AV_LOG_DEBUG, "prim channels: %i\n", s->prim_channels);
00475 for(i = 0; i < s->prim_channels; i++){
00476 av_log(s->avctx, AV_LOG_DEBUG, "subband activity: %i\n", s->subband_activity[i]);
00477 av_log(s->avctx, AV_LOG_DEBUG, "vq start subband: %i\n", s->vq_start_subband[i]);
00478 av_log(s->avctx, AV_LOG_DEBUG, "joint intensity: %i\n", s->joint_intensity[i]);
00479 av_log(s->avctx, AV_LOG_DEBUG, "transient mode codebook: %i\n", s->transient_huffman[i]);
00480 av_log(s->avctx, AV_LOG_DEBUG, "scale factor codebook: %i\n", s->scalefactor_huffman[i]);
00481 av_log(s->avctx, AV_LOG_DEBUG, "bit allocation quantizer: %i\n", s->bitalloc_huffman[i]);
00482 av_log(s->avctx, AV_LOG_DEBUG, "quant index huff:");
00483 for (j = 0; j < 11; j++)
00484 av_log(s->avctx, AV_LOG_DEBUG, " %i",
00485 s->quant_index_huffman[i][j]);
00486 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00487 av_log(s->avctx, AV_LOG_DEBUG, "scalefac adj:");
00488 for (j = 0; j < 11; j++)
00489 av_log(s->avctx, AV_LOG_DEBUG, " %1.3f", s->scalefactor_adj[i][j]);
00490 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00491 }
00492 #endif
00493
00494 return 0;
00495 }
00496
00497
00498 static inline int get_scale(GetBitContext *gb, int level, int value)
00499 {
00500 if (level < 5) {
00501
00502 value += get_bitalloc(gb, &dca_scalefactor, level);
00503 } else if(level < 8)
00504 value = get_bits(gb, level + 1);
00505 return value;
00506 }
00507
00508 static int dca_subframe_header(DCAContext * s)
00509 {
00510
00511 int j, k;
00512
00513 s->subsubframes = get_bits(&s->gb, 2) + 1;
00514 s->partial_samples = get_bits(&s->gb, 3);
00515 for (j = 0; j < s->prim_channels; j++) {
00516 for (k = 0; k < s->subband_activity[j]; k++)
00517 s->prediction_mode[j][k] = get_bits(&s->gb, 1);
00518 }
00519
00520
00521 for (j = 0; j < s->prim_channels; j++) {
00522 for (k = 0; k < s->subband_activity[j]; k++) {
00523 if (s->prediction_mode[j][k] > 0) {
00524
00525 s->prediction_vq[j][k] = get_bits(&s->gb, 12);
00526 }
00527 }
00528 }
00529
00530
00531 for (j = 0; j < s->prim_channels; j++) {
00532 for (k = 0; k < s->vq_start_subband[j]; k++) {
00533 if (s->bitalloc_huffman[j] == 6)
00534 s->bitalloc[j][k] = get_bits(&s->gb, 5);
00535 else if (s->bitalloc_huffman[j] == 5)
00536 s->bitalloc[j][k] = get_bits(&s->gb, 4);
00537 else if (s->bitalloc_huffman[j] == 7) {
00538 av_log(s->avctx, AV_LOG_ERROR,
00539 "Invalid bit allocation index\n");
00540 return -1;
00541 } else {
00542 s->bitalloc[j][k] =
00543 get_bitalloc(&s->gb, &dca_bitalloc_index, s->bitalloc_huffman[j]);
00544 }
00545
00546 if (s->bitalloc[j][k] > 26) {
00547
00548
00549 return -1;
00550 }
00551 }
00552 }
00553
00554
00555 for (j = 0; j < s->prim_channels; j++) {
00556 for (k = 0; k < s->subband_activity[j]; k++) {
00557 s->transition_mode[j][k] = 0;
00558 if (s->subsubframes > 1 &&
00559 k < s->vq_start_subband[j] && s->bitalloc[j][k] > 0) {
00560 s->transition_mode[j][k] =
00561 get_bitalloc(&s->gb, &dca_tmode, s->transient_huffman[j]);
00562 }
00563 }
00564 }
00565
00566 for (j = 0; j < s->prim_channels; j++) {
00567 const uint32_t *scale_table;
00568 int scale_sum;
00569
00570 memset(s->scale_factor[j], 0, s->subband_activity[j] * sizeof(s->scale_factor[0][0][0]) * 2);
00571
00572 if (s->scalefactor_huffman[j] == 6)
00573 scale_table = scale_factor_quant7;
00574 else
00575 scale_table = scale_factor_quant6;
00576
00577
00578 scale_sum = 0;
00579
00580 for (k = 0; k < s->subband_activity[j]; k++) {
00581 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0) {
00582 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
00583 s->scale_factor[j][k][0] = scale_table[scale_sum];
00584 }
00585
00586 if (k < s->vq_start_subband[j] && s->transition_mode[j][k]) {
00587
00588 scale_sum = get_scale(&s->gb, s->scalefactor_huffman[j], scale_sum);
00589 s->scale_factor[j][k][1] = scale_table[scale_sum];
00590 }
00591 }
00592 }
00593
00594
00595 for (j = 0; j < s->prim_channels; j++) {
00596
00597 if (s->joint_intensity[j] > 0)
00598 s->joint_huff[j] = get_bits(&s->gb, 3);
00599 }
00600
00601
00602 for (j = 0; j < s->prim_channels; j++) {
00603 int source_channel;
00604
00605
00606 if (s->joint_intensity[j] > 0) {
00607 int scale = 0;
00608 source_channel = s->joint_intensity[j] - 1;
00609
00610
00611
00612
00613 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++) {
00614 scale = get_scale(&s->gb, s->joint_huff[j], 0);
00615 scale += 64;
00616 s->joint_scale_factor[j][k] = scale;
00617 }
00618
00619 if (!(s->debug_flag & 0x02)) {
00620 av_log(s->avctx, AV_LOG_DEBUG,
00621 "Joint stereo coding not supported\n");
00622 s->debug_flag |= 0x02;
00623 }
00624 }
00625 }
00626
00627
00628 if (s->prim_channels > 2) {
00629 if(s->downmix) {
00630 for (j = 0; j < s->prim_channels; j++) {
00631 s->downmix_coef[j][0] = get_bits(&s->gb, 7);
00632 s->downmix_coef[j][1] = get_bits(&s->gb, 7);
00633 }
00634 } else {
00635 int am = s->amode & DCA_CHANNEL_MASK;
00636 for (j = 0; j < s->prim_channels; j++) {
00637 s->downmix_coef[j][0] = dca_default_coeffs[am][j][0];
00638 s->downmix_coef[j][1] = dca_default_coeffs[am][j][1];
00639 }
00640 }
00641 }
00642
00643
00644 if (s->dynrange)
00645 s->dynrange_coef = get_bits(&s->gb, 8);
00646
00647
00648 if (s->crc_present) {
00649 get_bits(&s->gb, 16);
00650 }
00651
00652
00653
00654
00655
00656
00657 for (j = 0; j < s->prim_channels; j++)
00658 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00659
00660 s->high_freq_vq[j][k] = get_bits(&s->gb, 10);
00661
00662
00663 if (s->lfe) {
00664
00665 int lfe_samples = 2 * s->lfe * s->subsubframes;
00666 float lfe_scale;
00667
00668 for (j = lfe_samples; j < lfe_samples * 2; j++) {
00669
00670 s->lfe_data[j] = get_sbits(&s->gb, 8);
00671 }
00672
00673
00674 s->lfe_scale_factor = scale_factor_quant7[get_bits(&s->gb, 8)];
00675
00676
00677 lfe_scale = 0.035 * s->lfe_scale_factor;
00678
00679 for (j = lfe_samples; j < lfe_samples * 2; j++)
00680 s->lfe_data[j] *= lfe_scale;
00681 }
00682
00683 #ifdef TRACE
00684 av_log(s->avctx, AV_LOG_DEBUG, "subsubframes: %i\n", s->subsubframes);
00685 av_log(s->avctx, AV_LOG_DEBUG, "partial samples: %i\n",
00686 s->partial_samples);
00687 for (j = 0; j < s->prim_channels; j++) {
00688 av_log(s->avctx, AV_LOG_DEBUG, "prediction mode:");
00689 for (k = 0; k < s->subband_activity[j]; k++)
00690 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->prediction_mode[j][k]);
00691 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00692 }
00693 for (j = 0; j < s->prim_channels; j++) {
00694 for (k = 0; k < s->subband_activity[j]; k++)
00695 av_log(s->avctx, AV_LOG_DEBUG,
00696 "prediction coefs: %f, %f, %f, %f\n",
00697 (float) adpcm_vb[s->prediction_vq[j][k]][0] / 8192,
00698 (float) adpcm_vb[s->prediction_vq[j][k]][1] / 8192,
00699 (float) adpcm_vb[s->prediction_vq[j][k]][2] / 8192,
00700 (float) adpcm_vb[s->prediction_vq[j][k]][3] / 8192);
00701 }
00702 for (j = 0; j < s->prim_channels; j++) {
00703 av_log(s->avctx, AV_LOG_DEBUG, "bitalloc index: ");
00704 for (k = 0; k < s->vq_start_subband[j]; k++)
00705 av_log(s->avctx, AV_LOG_DEBUG, "%2.2i ", s->bitalloc[j][k]);
00706 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00707 }
00708 for (j = 0; j < s->prim_channels; j++) {
00709 av_log(s->avctx, AV_LOG_DEBUG, "Transition mode:");
00710 for (k = 0; k < s->subband_activity[j]; k++)
00711 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->transition_mode[j][k]);
00712 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00713 }
00714 for (j = 0; j < s->prim_channels; j++) {
00715 av_log(s->avctx, AV_LOG_DEBUG, "Scale factor:");
00716 for (k = 0; k < s->subband_activity[j]; k++) {
00717 if (k >= s->vq_start_subband[j] || s->bitalloc[j][k] > 0)
00718 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->scale_factor[j][k][0]);
00719 if (k < s->vq_start_subband[j] && s->transition_mode[j][k])
00720 av_log(s->avctx, AV_LOG_DEBUG, " %i(t)", s->scale_factor[j][k][1]);
00721 }
00722 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00723 }
00724 for (j = 0; j < s->prim_channels; j++) {
00725 if (s->joint_intensity[j] > 0) {
00726 int source_channel = s->joint_intensity[j] - 1;
00727 av_log(s->avctx, AV_LOG_DEBUG, "Joint scale factor index:\n");
00728 for (k = s->subband_activity[j]; k < s->subband_activity[source_channel]; k++)
00729 av_log(s->avctx, AV_LOG_DEBUG, " %i", s->joint_scale_factor[j][k]);
00730 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00731 }
00732 }
00733 if (s->prim_channels > 2 && s->downmix) {
00734 av_log(s->avctx, AV_LOG_DEBUG, "Downmix coeffs:\n");
00735 for (j = 0; j < s->prim_channels; j++) {
00736 av_log(s->avctx, AV_LOG_DEBUG, "Channel 0,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][0]]);
00737 av_log(s->avctx, AV_LOG_DEBUG, "Channel 1,%d = %f\n", j, dca_downmix_coeffs[s->downmix_coef[j][1]]);
00738 }
00739 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00740 }
00741 for (j = 0; j < s->prim_channels; j++)
00742 for (k = s->vq_start_subband[j]; k < s->subband_activity[j]; k++)
00743 av_log(s->avctx, AV_LOG_DEBUG, "VQ index: %i\n", s->high_freq_vq[j][k]);
00744 if(s->lfe){
00745 int lfe_samples = 2 * s->lfe * s->subsubframes;
00746 av_log(s->avctx, AV_LOG_DEBUG, "LFE samples:\n");
00747 for (j = lfe_samples; j < lfe_samples * 2; j++)
00748 av_log(s->avctx, AV_LOG_DEBUG, " %f", s->lfe_data[j]);
00749 av_log(s->avctx, AV_LOG_DEBUG, "\n");
00750 }
00751 #endif
00752
00753 return 0;
00754 }
00755
00756 static void qmf_32_subbands(DCAContext * s, int chans,
00757 float samples_in[32][8], float *samples_out,
00758 float scale, float bias)
00759 {
00760 const float *prCoeff;
00761 int i;
00762
00763 int sb_act = s->subband_activity[chans];
00764 int subindex;
00765
00766 scale *= sqrt(1/8.0);
00767
00768
00769 if (!s->multirate_inter)
00770 prCoeff = fir_32bands_nonperfect;
00771 else
00772 prCoeff = fir_32bands_perfect;
00773
00774
00775 for (subindex = 0; subindex < 8; subindex++) {
00776
00777 for (i = 0; i < sb_act; i++){
00778 uint32_t v = AV_RN32A(&samples_in[i][subindex]) ^ ((i-1)&2)<<30;
00779 AV_WN32A(&s->raXin[i], v);
00780 }
00781 for (; i < 32; i++)
00782 s->raXin[i] = 0.0;
00783
00784 s->synth.synth_filter_float(&s->imdct,
00785 s->subband_fir_hist[chans], &s->hist_index[chans],
00786 s->subband_fir_noidea[chans], prCoeff,
00787 samples_out, s->raXin, scale, bias);
00788 samples_out+= 32;
00789
00790 }
00791 }
00792
00793 static void lfe_interpolation_fir(DCAContext *s, int decimation_select,
00794 int num_deci_sample, float *samples_in,
00795 float *samples_out, float scale,
00796 float bias)
00797 {
00798
00799
00800
00801
00802
00803
00804
00805
00806 int decifactor;
00807 const float *prCoeff;
00808 int deciindex;
00809
00810
00811 if (decimation_select == 1) {
00812 decifactor = 64;
00813 prCoeff = lfe_fir_128;
00814 } else {
00815 decifactor = 32;
00816 prCoeff = lfe_fir_64;
00817 }
00818
00819 for (deciindex = 0; deciindex < num_deci_sample; deciindex++) {
00820 s->dcadsp.lfe_fir(samples_out, samples_in, prCoeff, decifactor,
00821 scale, bias);
00822 samples_in++;
00823 samples_out += 2 * decifactor;
00824 }
00825 }
00826
00827
00828 #define MIX_REAR1(samples, si1, rs, coef) \
00829 samples[i] += samples[si1] * coef[rs][0]; \
00830 samples[i+256] += samples[si1] * coef[rs][1];
00831
00832 #define MIX_REAR2(samples, si1, si2, rs, coef) \
00833 samples[i] += samples[si1] * coef[rs][0] + samples[si2] * coef[rs+1][0]; \
00834 samples[i+256] += samples[si1] * coef[rs][1] + samples[si2] * coef[rs+1][1];
00835
00836 #define MIX_FRONT3(samples, coef) \
00837 t = samples[i]; \
00838 samples[i] = t * coef[0][0] + samples[i+256] * coef[1][0] + samples[i+512] * coef[2][0]; \
00839 samples[i+256] = t * coef[0][1] + samples[i+256] * coef[1][1] + samples[i+512] * coef[2][1];
00840
00841 #define DOWNMIX_TO_STEREO(op1, op2) \
00842 for(i = 0; i < 256; i++){ \
00843 op1 \
00844 op2 \
00845 }
00846
00847 static void dca_downmix(float *samples, int srcfmt,
00848 int downmix_coef[DCA_PRIM_CHANNELS_MAX][2])
00849 {
00850 int i;
00851 float t;
00852 float coef[DCA_PRIM_CHANNELS_MAX][2];
00853
00854 for(i=0; i<DCA_PRIM_CHANNELS_MAX; i++) {
00855 coef[i][0] = dca_downmix_coeffs[downmix_coef[i][0]];
00856 coef[i][1] = dca_downmix_coeffs[downmix_coef[i][1]];
00857 }
00858
00859 switch (srcfmt) {
00860 case DCA_MONO:
00861 case DCA_CHANNEL:
00862 case DCA_STEREO_TOTAL:
00863 case DCA_STEREO_SUMDIFF:
00864 case DCA_4F2R:
00865 av_log(NULL, 0, "Not implemented!\n");
00866 break;
00867 case DCA_STEREO:
00868 break;
00869 case DCA_3F:
00870 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),);
00871 break;
00872 case DCA_2F1R:
00873 DOWNMIX_TO_STEREO(MIX_REAR1(samples, i + 512, 2, coef),);
00874 break;
00875 case DCA_3F1R:
00876 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
00877 MIX_REAR1(samples, i + 768, 3, coef));
00878 break;
00879 case DCA_2F2R:
00880 DOWNMIX_TO_STEREO(MIX_REAR2(samples, i + 512, i + 768, 2, coef),);
00881 break;
00882 case DCA_3F2R:
00883 DOWNMIX_TO_STEREO(MIX_FRONT3(samples, coef),
00884 MIX_REAR2(samples, i + 768, i + 1024, 3, coef));
00885 break;
00886 }
00887 }
00888
00889
00890
00891
00892 static int decode_blockcode(int code, int levels, int *values)
00893 {
00894 int i;
00895 int offset = (levels - 1) >> 1;
00896
00897 for (i = 0; i < 4; i++) {
00898 int div = FASTDIV(code, levels);
00899 values[i] = code - offset - div*levels;
00900 code = div;
00901 }
00902
00903 if (code == 0)
00904 return 0;
00905 else {
00906 av_log(NULL, AV_LOG_ERROR, "ERROR: block code look-up failed\n");
00907 return -1;
00908 }
00909 }
00910
00911 static const uint8_t abits_sizes[7] = { 7, 10, 12, 13, 15, 17, 19 };
00912 static const uint8_t abits_levels[7] = { 3, 5, 7, 9, 13, 17, 25 };
00913
00914 static int dca_subsubframe(DCAContext * s)
00915 {
00916 int k, l;
00917 int subsubframe = s->current_subsubframe;
00918
00919 const float *quant_step_table;
00920
00921
00922 LOCAL_ALIGNED_16(float, subband_samples, [DCA_PRIM_CHANNELS_MAX], [DCA_SUBBANDS][8]);
00923 LOCAL_ALIGNED_16(int, block, [8]);
00924
00925
00926
00927
00928
00929
00930 if (s->bit_rate_index == 0x1f)
00931 quant_step_table = lossless_quant_d;
00932 else
00933 quant_step_table = lossy_quant_d;
00934
00935 for (k = 0; k < s->prim_channels; k++) {
00936 for (l = 0; l < s->vq_start_subband[k]; l++) {
00937 int m;
00938
00939
00940 int abits = s->bitalloc[k][l];
00941
00942 float quant_step_size = quant_step_table[abits];
00943
00944
00945
00946
00947
00948
00949 int sel = s->quant_index_huffman[k][abits];
00950
00951
00952
00953
00954 if(!abits){
00955 memset(subband_samples[k][l], 0, 8 * sizeof(subband_samples[0][0][0]));
00956 } else {
00957
00958 int sfi = s->transition_mode[k][l] && subsubframe >= s->transition_mode[k][l];
00959 float rscale = quant_step_size * s->scale_factor[k][l][sfi] * s->scalefactor_adj[k][sel];
00960
00961 if(abits >= 11 || !dca_smpl_bitalloc[abits].vlc[sel].table){
00962 if(abits <= 7){
00963
00964 int block_code1, block_code2, size, levels;
00965
00966 size = abits_sizes[abits-1];
00967 levels = abits_levels[abits-1];
00968
00969 block_code1 = get_bits(&s->gb, size);
00970
00971 decode_blockcode(block_code1, levels, block);
00972 block_code2 = get_bits(&s->gb, size);
00973 decode_blockcode(block_code2, levels, &block[4]);
00974 }else{
00975
00976 for (m = 0; m < 8; m++)
00977 block[m] = get_sbits(&s->gb, abits - 3);
00978 }
00979 }else{
00980
00981 for (m = 0; m < 8; m++)
00982 block[m] = get_bitalloc(&s->gb, &dca_smpl_bitalloc[abits], sel);
00983 }
00984
00985 s->dsp.int32_to_float_fmul_scalar(subband_samples[k][l],
00986 block, rscale, 8);
00987 }
00988
00989
00990
00991
00992 if (s->prediction_mode[k][l]) {
00993 int n;
00994 for (m = 0; m < 8; m++) {
00995 for (n = 1; n <= 4; n++)
00996 if (m >= n)
00997 subband_samples[k][l][m] +=
00998 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
00999 subband_samples[k][l][m - n] / 8192);
01000 else if (s->predictor_history)
01001 subband_samples[k][l][m] +=
01002 (adpcm_vb[s->prediction_vq[k][l]][n - 1] *
01003 s->subband_samples_hist[k][l][m - n +
01004 4] / 8192);
01005 }
01006 }
01007 }
01008
01009
01010
01011
01012 for (l = s->vq_start_subband[k]; l < s->subband_activity[k]; l++) {
01013
01014
01015 int m;
01016
01017 if (!s->debug_flag & 0x01) {
01018 av_log(s->avctx, AV_LOG_DEBUG, "Stream with high frequencies VQ coding\n");
01019 s->debug_flag |= 0x01;
01020 }
01021
01022 for (m = 0; m < 8; m++) {
01023 subband_samples[k][l][m] =
01024 high_freq_vq[s->high_freq_vq[k][l]][subsubframe * 8 +
01025 m]
01026 * (float) s->scale_factor[k][l][0] / 16.0;
01027 }
01028 }
01029 }
01030
01031
01032 if (s->aspf || subsubframe == s->subsubframes - 1) {
01033 if (0xFFFF == get_bits(&s->gb, 16)) {
01034 #ifdef TRACE
01035 av_log(s->avctx, AV_LOG_DEBUG, "Got subframe DSYNC\n");
01036 #endif
01037 } else {
01038 av_log(s->avctx, AV_LOG_ERROR, "Didn't get subframe DSYNC\n");
01039 }
01040 }
01041
01042
01043 for (k = 0; k < s->prim_channels; k++)
01044 for (l = 0; l < s->vq_start_subband[k]; l++)
01045 memcpy(s->subband_samples_hist[k][l], &subband_samples[k][l][4],
01046 4 * sizeof(subband_samples[0][0][0]));
01047
01048
01049 for (k = 0; k < s->prim_channels; k++) {
01050
01051
01052 qmf_32_subbands(s, k, subband_samples[k], &s->samples[256 * s->channel_order_tab[k]],
01053 M_SQRT1_2*s->scale_bias ,
01054 s->add_bias );
01055 }
01056
01057
01058
01059 if (s->prim_channels > dca_channels[s->output & DCA_CHANNEL_MASK]) {
01060 dca_downmix(s->samples, s->amode, s->downmix_coef);
01061 }
01062
01063
01064 if (s->output & DCA_LFE) {
01065 int lfe_samples = 2 * s->lfe * s->subsubframes;
01066
01067 lfe_interpolation_fir(s, s->lfe, 2 * s->lfe,
01068 s->lfe_data + lfe_samples +
01069 2 * s->lfe * subsubframe,
01070 &s->samples[256 * dca_lfe_index[s->amode]],
01071 (1.0/256.0)*s->scale_bias, s->add_bias);
01072
01073 }
01074
01075 return 0;
01076 }
01077
01078
01079 static int dca_subframe_footer(DCAContext * s)
01080 {
01081 int aux_data_count = 0, i;
01082 int lfe_samples;
01083
01084
01085
01086
01087
01088 if (s->timestamp)
01089 get_bits(&s->gb, 32);
01090
01091 if (s->aux_data)
01092 aux_data_count = get_bits(&s->gb, 6);
01093
01094 for (i = 0; i < aux_data_count; i++)
01095 get_bits(&s->gb, 8);
01096
01097 if (s->crc_present && (s->downmix || s->dynrange))
01098 get_bits(&s->gb, 16);
01099
01100 lfe_samples = 2 * s->lfe * s->subsubframes;
01101 for (i = 0; i < lfe_samples; i++) {
01102 s->lfe_data[i] = s->lfe_data[i + lfe_samples];
01103 }
01104
01105 return 0;
01106 }
01107
01114 static int dca_decode_block(DCAContext * s)
01115 {
01116
01117
01118 if (s->current_subframe >= s->subframes) {
01119 av_log(s->avctx, AV_LOG_DEBUG, "check failed: %i>%i",
01120 s->current_subframe, s->subframes);
01121 return -1;
01122 }
01123
01124 if (!s->current_subsubframe) {
01125 #ifdef TRACE
01126 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_header\n");
01127 #endif
01128
01129 if (dca_subframe_header(s))
01130 return -1;
01131 }
01132
01133
01134 #ifdef TRACE
01135 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subsubframe\n");
01136 #endif
01137 if (dca_subsubframe(s))
01138 return -1;
01139
01140
01141 s->current_subsubframe++;
01142 if (s->current_subsubframe >= s->subsubframes) {
01143 s->current_subsubframe = 0;
01144 s->current_subframe++;
01145 }
01146 if (s->current_subframe >= s->subframes) {
01147 #ifdef TRACE
01148 av_log(s->avctx, AV_LOG_DEBUG, "DSYNC dca_subframe_footer\n");
01149 #endif
01150
01151 if (dca_subframe_footer(s))
01152 return -1;
01153 }
01154
01155 return 0;
01156 }
01157
01161 static int dca_convert_bitstream(const uint8_t * src, int src_size, uint8_t * dst,
01162 int max_size)
01163 {
01164 uint32_t mrk;
01165 int i, tmp;
01166 const uint16_t *ssrc = (const uint16_t *) src;
01167 uint16_t *sdst = (uint16_t *) dst;
01168 PutBitContext pb;
01169
01170 if((unsigned)src_size > (unsigned)max_size) {
01171
01172
01173 src_size = max_size;
01174 }
01175
01176 mrk = AV_RB32(src);
01177 switch (mrk) {
01178 case DCA_MARKER_RAW_BE:
01179 memcpy(dst, src, src_size);
01180 return src_size;
01181 case DCA_MARKER_RAW_LE:
01182 for (i = 0; i < (src_size + 1) >> 1; i++)
01183 *sdst++ = bswap_16(*ssrc++);
01184 return src_size;
01185 case DCA_MARKER_14B_BE:
01186 case DCA_MARKER_14B_LE:
01187 init_put_bits(&pb, dst, max_size);
01188 for (i = 0; i < (src_size + 1) >> 1; i++, src += 2) {
01189 tmp = ((mrk == DCA_MARKER_14B_BE) ? AV_RB16(src) : AV_RL16(src)) & 0x3FFF;
01190 put_bits(&pb, 14, tmp);
01191 }
01192 flush_put_bits(&pb);
01193 return (put_bits_count(&pb) + 7) >> 3;
01194 default:
01195 return -1;
01196 }
01197 }
01198
01203 static int dca_decode_frame(AVCodecContext * avctx,
01204 void *data, int *data_size,
01205 AVPacket *avpkt)
01206 {
01207 const uint8_t *buf = avpkt->data;
01208 int buf_size = avpkt->size;
01209
01210 int i;
01211 int16_t *samples = data;
01212 DCAContext *s = avctx->priv_data;
01213 int channels;
01214
01215
01216 s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
01217 if (s->dca_buffer_size == -1) {
01218 av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
01219 return -1;
01220 }
01221
01222 init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
01223 if (dca_parse_frame_header(s) < 0) {
01224
01225 *data_size=0;
01226 return buf_size;
01227 }
01228
01229 avctx->sample_rate = s->sample_rate;
01230 avctx->bit_rate = s->bit_rate;
01231
01232 channels = s->prim_channels + !!s->lfe;
01233
01234 if (s->amode<16) {
01235 avctx->channel_layout = dca_core_channel_layout[s->amode];
01236
01237 if (s->lfe) {
01238 avctx->channel_layout |= CH_LOW_FREQUENCY;
01239 s->channel_order_tab = dca_channel_reorder_lfe[s->amode];
01240 } else
01241 s->channel_order_tab = dca_channel_reorder_nolfe[s->amode];
01242
01243 if (s->prim_channels > 0 &&
01244 s->channel_order_tab[s->prim_channels - 1] < 0)
01245 return -1;
01246
01247 if(avctx->request_channels == 2 && s->prim_channels > 2) {
01248 channels = 2;
01249 s->output = DCA_STEREO;
01250 avctx->channel_layout = CH_LAYOUT_STEREO;
01251 }
01252 } else {
01253 av_log(avctx, AV_LOG_ERROR, "Non standard configuration %d !\n",s->amode);
01254 return -1;
01255 }
01256
01257
01258
01259
01260
01261
01262
01263 if (!avctx->channels)
01264 avctx->channels = channels;
01265
01266 if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
01267 return -1;
01268 *data_size = 256 / 8 * s->sample_blocks * sizeof(int16_t) * channels;
01269 for (i = 0; i < (s->sample_blocks / 8); i++) {
01270 dca_decode_block(s);
01271 s->dsp.float_to_int16_interleave(samples, s->samples_chanptr, 256, channels);
01272 samples += 256 * channels;
01273 }
01274
01275 return buf_size;
01276 }
01277
01278
01279
01286 static av_cold int dca_decode_init(AVCodecContext * avctx)
01287 {
01288 DCAContext *s = avctx->priv_data;
01289 int i;
01290
01291 s->avctx = avctx;
01292 dca_init_vlcs();
01293
01294 dsputil_init(&s->dsp, avctx);
01295 ff_mdct_init(&s->imdct, 6, 1, 1.0);
01296 ff_synth_filter_init(&s->synth);
01297 ff_dcadsp_init(&s->dcadsp);
01298
01299 for(i = 0; i < 6; i++)
01300 s->samples_chanptr[i] = s->samples + i * 256;
01301 avctx->sample_fmt = SAMPLE_FMT_S16;
01302
01303 if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
01304 s->add_bias = 385.0f;
01305 s->scale_bias = 1.0 / 32768.0;
01306 } else {
01307 s->add_bias = 0.0f;
01308 s->scale_bias = 1.0;
01309
01310
01311 if (avctx->channels > 0 && avctx->request_channels < avctx->channels &&
01312 avctx->request_channels == 2) {
01313 avctx->channels = avctx->request_channels;
01314 }
01315 }
01316
01317
01318 return 0;
01319 }
01320
01321 static av_cold int dca_decode_end(AVCodecContext * avctx)
01322 {
01323 DCAContext *s = avctx->priv_data;
01324 ff_mdct_end(&s->imdct);
01325 return 0;
01326 }
01327
01328 AVCodec dca_decoder = {
01329 .name = "dca",
01330 .type = AVMEDIA_TYPE_AUDIO,
01331 .id = CODEC_ID_DTS,
01332 .priv_data_size = sizeof(DCAContext),
01333 .init = dca_decode_init,
01334 .decode = dca_decode_frame,
01335 .close = dca_decode_end,
01336 .long_name = NULL_IF_CONFIG_SMALL("DCA (DTS Coherent Acoustics)"),
01337 };