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