00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00033 #include <math.h>
00034 #include <stddef.h>
00035 #include <stdio.h>
00036
00037 #define ALT_BITSTREAM_READER_LE
00038 #include "avcodec.h"
00039 #include "bitstream.h"
00040 #include "dsputil.h"
00041
00042 #ifdef CONFIG_MPEGAUDIO_HP
00043 #define USE_HIGHPRECISION
00044 #endif
00045
00046 #include "mpegaudio.h"
00047
00048 #include "qdm2data.h"
00049
00050 #undef NDEBUG
00051 #include <assert.h>
00052
00053
00054 #define SOFTCLIP_THRESHOLD 27600
00055 #define HARDCLIP_THRESHOLD 35716
00056
00057
00058 #define QDM2_LIST_ADD(list, size, packet) \
00059 do { \
00060 if (size > 0) { \
00061 list[size - 1].next = &list[size]; \
00062 } \
00063 list[size].packet = packet; \
00064 list[size].next = NULL; \
00065 size++; \
00066 } while(0)
00067
00068
00069 #define QDM2_SB_USED(sub_sampling) (((sub_sampling) >= 2) ? 30 : 8 << (sub_sampling))
00070
00071 #define FIX_NOISE_IDX(noise_idx) \
00072 if ((noise_idx) >= 3840) \
00073 (noise_idx) -= 3840; \
00074
00075 #define SB_DITHERING_NOISE(sb,noise_idx) (noise_table[(noise_idx)++] * sb_noise_attenuation[(sb)])
00076
00077 #define BITS_LEFT(length,gb) ((length) - get_bits_count ((gb)))
00078
00079 #define SAMPLES_NEEDED \
00080 av_log (NULL,AV_LOG_INFO,"This file triggers some untested code. Please contact the developers.\n");
00081
00082 #define SAMPLES_NEEDED_2(why) \
00083 av_log (NULL,AV_LOG_INFO,"This file triggers some missing code. Please contact the developers.\nPosition: %s\n",why);
00084
00085
00086 typedef int8_t sb_int8_array[2][30][64];
00087
00091 typedef struct {
00092 int type;
00093 unsigned int size;
00094 const uint8_t *data;
00095 } QDM2SubPacket;
00096
00100 typedef struct QDM2SubPNode {
00101 QDM2SubPacket *packet;
00102 struct QDM2SubPNode *next;
00103 } QDM2SubPNode;
00104
00105 typedef struct {
00106 float level;
00107 float *samples_im;
00108 float *samples_re;
00109 const float *table;
00110 int phase;
00111 int phase_shift;
00112 int duration;
00113 short time_index;
00114 short cutoff;
00115 } FFTTone;
00116
00117 typedef struct {
00118 int16_t sub_packet;
00119 uint8_t channel;
00120 int16_t offset;
00121 int16_t exp;
00122 uint8_t phase;
00123 } FFTCoefficient;
00124
00125 typedef struct {
00126 float re;
00127 float im;
00128 } QDM2Complex;
00129
00130 typedef struct {
00131 DECLARE_ALIGNED_16(QDM2Complex, complex[256 + 1]);
00132 float samples_im[MPA_MAX_CHANNELS][256];
00133 float samples_re[MPA_MAX_CHANNELS][256];
00134 } QDM2FFT;
00135
00139 typedef struct {
00141 int nb_channels;
00142 int channels;
00143 int group_size;
00144 int fft_size;
00145 int checksum_size;
00146
00148 int group_order;
00149 int fft_order;
00150 int fft_frame_size;
00151 int frame_size;
00152 int frequency_range;
00153 int sub_sampling;
00154 int coeff_per_sb_select;
00155 int cm_table_select;
00156
00158 QDM2SubPacket sub_packets[16];
00159 QDM2SubPNode sub_packet_list_A[16];
00160 QDM2SubPNode sub_packet_list_B[16];
00161 int sub_packets_B;
00162 QDM2SubPNode sub_packet_list_C[16];
00163 QDM2SubPNode sub_packet_list_D[16];
00164
00166 FFTTone fft_tones[1000];
00167 int fft_tone_start;
00168 int fft_tone_end;
00169 FFTCoefficient fft_coefs[1000];
00170 int fft_coefs_index;
00171 int fft_coefs_min_index[5];
00172 int fft_coefs_max_index[5];
00173 int fft_level_exp[6];
00174 FFTContext fft_ctx;
00175 FFTComplex exptab[128];
00176 QDM2FFT fft;
00177
00179 const uint8_t *compressed_data;
00180 int compressed_size;
00181 float output_buffer[1024];
00182
00184 DECLARE_ALIGNED_16(MPA_INT, synth_buf[MPA_MAX_CHANNELS][512*2]);
00185 int synth_buf_offset[MPA_MAX_CHANNELS];
00186 DECLARE_ALIGNED_16(int32_t, sb_samples[MPA_MAX_CHANNELS][128][SBLIMIT]);
00187
00189 float tone_level[MPA_MAX_CHANNELS][30][64];
00190 int8_t coding_method[MPA_MAX_CHANNELS][30][64];
00191 int8_t quantized_coeffs[MPA_MAX_CHANNELS][10][8];
00192 int8_t tone_level_idx_base[MPA_MAX_CHANNELS][30][8];
00193 int8_t tone_level_idx_hi1[MPA_MAX_CHANNELS][3][8][8];
00194 int8_t tone_level_idx_mid[MPA_MAX_CHANNELS][26][8];
00195 int8_t tone_level_idx_hi2[MPA_MAX_CHANNELS][26];
00196 int8_t tone_level_idx[MPA_MAX_CHANNELS][30][64];
00197 int8_t tone_level_idx_temp[MPA_MAX_CHANNELS][30][64];
00198
00199
00200 int has_errors;
00201 int superblocktype_2_3;
00202 int do_synth_filter;
00203
00204 int sub_packet;
00205 int noise_idx;
00206 } QDM2Context;
00207
00208
00209 static uint8_t empty_buffer[FF_INPUT_BUFFER_PADDING_SIZE];
00210
00211 static VLC vlc_tab_level;
00212 static VLC vlc_tab_diff;
00213 static VLC vlc_tab_run;
00214 static VLC fft_level_exp_alt_vlc;
00215 static VLC fft_level_exp_vlc;
00216 static VLC fft_stereo_exp_vlc;
00217 static VLC fft_stereo_phase_vlc;
00218 static VLC vlc_tab_tone_level_idx_hi1;
00219 static VLC vlc_tab_tone_level_idx_mid;
00220 static VLC vlc_tab_tone_level_idx_hi2;
00221 static VLC vlc_tab_type30;
00222 static VLC vlc_tab_type34;
00223 static VLC vlc_tab_fft_tone_offset[5];
00224
00225 static uint16_t softclip_table[HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD + 1];
00226 static float noise_table[4096];
00227 static uint8_t random_dequant_index[256][5];
00228 static uint8_t random_dequant_type24[128][3];
00229 static float noise_samples[128];
00230
00231 static DECLARE_ALIGNED_16(MPA_INT, mpa_window[512]);
00232
00233
00234 static void softclip_table_init(void) {
00235 int i;
00236 double dfl = SOFTCLIP_THRESHOLD - 32767;
00237 float delta = 1.0 / -dfl;
00238 for (i = 0; i < HARDCLIP_THRESHOLD - SOFTCLIP_THRESHOLD + 1; i++)
00239 softclip_table[i] = SOFTCLIP_THRESHOLD - ((int)(sin((float)i * delta) * dfl) & 0x0000FFFF);
00240 }
00241
00242
00243
00244 static void rnd_table_init(void) {
00245 int i,j;
00246 uint32_t ldw,hdw;
00247 uint64_t tmp64_1;
00248 uint64_t random_seed = 0;
00249 float delta = 1.0 / 16384.0;
00250 for(i = 0; i < 4096 ;i++) {
00251 random_seed = random_seed * 214013 + 2531011;
00252 noise_table[i] = (delta * (float)(((int32_t)random_seed >> 16) & 0x00007FFF)- 1.0) * 1.3;
00253 }
00254
00255 for (i = 0; i < 256 ;i++) {
00256 random_seed = 81;
00257 ldw = i;
00258 for (j = 0; j < 5 ;j++) {
00259 random_dequant_index[i][j] = (uint8_t)((ldw / random_seed) & 0xFF);
00260 ldw = (uint32_t)ldw % (uint32_t)random_seed;
00261 tmp64_1 = (random_seed * 0x55555556);
00262 hdw = (uint32_t)(tmp64_1 >> 32);
00263 random_seed = (uint64_t)(hdw + (ldw >> 31));
00264 }
00265 }
00266 for (i = 0; i < 128 ;i++) {
00267 random_seed = 25;
00268 ldw = i;
00269 for (j = 0; j < 3 ;j++) {
00270 random_dequant_type24[i][j] = (uint8_t)((ldw / random_seed) & 0xFF);
00271 ldw = (uint32_t)ldw % (uint32_t)random_seed;
00272 tmp64_1 = (random_seed * 0x66666667);
00273 hdw = (uint32_t)(tmp64_1 >> 33);
00274 random_seed = hdw + (ldw >> 31);
00275 }
00276 }
00277 }
00278
00279
00280 static void init_noise_samples(void) {
00281 int i;
00282 int random_seed = 0;
00283 float delta = 1.0 / 16384.0;
00284 for (i = 0; i < 128;i++) {
00285 random_seed = random_seed * 214013 + 2531011;
00286 noise_samples[i] = (delta * (float)((random_seed >> 16) & 0x00007fff) - 1.0);
00287 }
00288 }
00289
00290
00291 static void qdm2_init_vlc(void)
00292 {
00293 init_vlc (&vlc_tab_level, 8, 24,
00294 vlc_tab_level_huffbits, 1, 1,
00295 vlc_tab_level_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00296
00297 init_vlc (&vlc_tab_diff, 8, 37,
00298 vlc_tab_diff_huffbits, 1, 1,
00299 vlc_tab_diff_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00300
00301 init_vlc (&vlc_tab_run, 5, 6,
00302 vlc_tab_run_huffbits, 1, 1,
00303 vlc_tab_run_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00304
00305 init_vlc (&fft_level_exp_alt_vlc, 8, 28,
00306 fft_level_exp_alt_huffbits, 1, 1,
00307 fft_level_exp_alt_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00308
00309 init_vlc (&fft_level_exp_vlc, 8, 20,
00310 fft_level_exp_huffbits, 1, 1,
00311 fft_level_exp_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00312
00313 init_vlc (&fft_stereo_exp_vlc, 6, 7,
00314 fft_stereo_exp_huffbits, 1, 1,
00315 fft_stereo_exp_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00316
00317 init_vlc (&fft_stereo_phase_vlc, 6, 9,
00318 fft_stereo_phase_huffbits, 1, 1,
00319 fft_stereo_phase_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00320
00321 init_vlc (&vlc_tab_tone_level_idx_hi1, 8, 20,
00322 vlc_tab_tone_level_idx_hi1_huffbits, 1, 1,
00323 vlc_tab_tone_level_idx_hi1_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00324
00325 init_vlc (&vlc_tab_tone_level_idx_mid, 8, 24,
00326 vlc_tab_tone_level_idx_mid_huffbits, 1, 1,
00327 vlc_tab_tone_level_idx_mid_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00328
00329 init_vlc (&vlc_tab_tone_level_idx_hi2, 8, 24,
00330 vlc_tab_tone_level_idx_hi2_huffbits, 1, 1,
00331 vlc_tab_tone_level_idx_hi2_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00332
00333 init_vlc (&vlc_tab_type30, 6, 9,
00334 vlc_tab_type30_huffbits, 1, 1,
00335 vlc_tab_type30_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00336
00337 init_vlc (&vlc_tab_type34, 5, 10,
00338 vlc_tab_type34_huffbits, 1, 1,
00339 vlc_tab_type34_huffcodes, 1, 1, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00340
00341 init_vlc (&vlc_tab_fft_tone_offset[0], 8, 23,
00342 vlc_tab_fft_tone_offset_0_huffbits, 1, 1,
00343 vlc_tab_fft_tone_offset_0_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00344
00345 init_vlc (&vlc_tab_fft_tone_offset[1], 8, 28,
00346 vlc_tab_fft_tone_offset_1_huffbits, 1, 1,
00347 vlc_tab_fft_tone_offset_1_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00348
00349 init_vlc (&vlc_tab_fft_tone_offset[2], 8, 32,
00350 vlc_tab_fft_tone_offset_2_huffbits, 1, 1,
00351 vlc_tab_fft_tone_offset_2_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00352
00353 init_vlc (&vlc_tab_fft_tone_offset[3], 8, 35,
00354 vlc_tab_fft_tone_offset_3_huffbits, 1, 1,
00355 vlc_tab_fft_tone_offset_3_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00356
00357 init_vlc (&vlc_tab_fft_tone_offset[4], 8, 38,
00358 vlc_tab_fft_tone_offset_4_huffbits, 1, 1,
00359 vlc_tab_fft_tone_offset_4_huffcodes, 2, 2, INIT_VLC_USE_STATIC | INIT_VLC_LE);
00360 }
00361
00362
00363
00364 static float f2i_scale = (float) (1 << (FRAC_BITS - 15));
00365
00366
00367 static int qdm2_get_vlc (GetBitContext *gb, VLC *vlc, int flag, int depth)
00368 {
00369 int value;
00370
00371 value = get_vlc2(gb, vlc->table, vlc->bits, depth);
00372
00373
00374 if (value-- == 0)
00375 value = get_bits (gb, get_bits (gb, 3) + 1);
00376
00377
00378 if (flag) {
00379 int tmp = vlc_stage3_values[value];
00380
00381 if ((value & ~3) > 0)
00382 tmp += get_bits (gb, (value >> 2));
00383 value = tmp;
00384 }
00385
00386 return value;
00387 }
00388
00389
00390 static int qdm2_get_se_vlc (VLC *vlc, GetBitContext *gb, int depth)
00391 {
00392 int value = qdm2_get_vlc (gb, vlc, 0, depth);
00393
00394 return (value & 1) ? ((value + 1) >> 1) : -(value >> 1);
00395 }
00396
00397
00407 static uint16_t qdm2_packet_checksum (const uint8_t *data, int length, int value) {
00408 int i;
00409
00410 for (i=0; i < length; i++)
00411 value -= data[i];
00412
00413 return (uint16_t)(value & 0xffff);
00414 }
00415
00416
00423 static void qdm2_decode_sub_packet_header (GetBitContext *gb, QDM2SubPacket *sub_packet)
00424 {
00425 sub_packet->type = get_bits (gb, 8);
00426
00427 if (sub_packet->type == 0) {
00428 sub_packet->size = 0;
00429 sub_packet->data = NULL;
00430 } else {
00431 sub_packet->size = get_bits (gb, 8);
00432
00433 if (sub_packet->type & 0x80) {
00434 sub_packet->size <<= 8;
00435 sub_packet->size |= get_bits (gb, 8);
00436 sub_packet->type &= 0x7f;
00437 }
00438
00439 if (sub_packet->type == 0x7f)
00440 sub_packet->type |= (get_bits (gb, 8) << 8);
00441
00442 sub_packet->data = &gb->buffer[get_bits_count(gb) / 8];
00443 }
00444
00445 av_log(NULL,AV_LOG_DEBUG,"Subpacket: type=%d size=%d start_offs=%x\n",
00446 sub_packet->type, sub_packet->size, get_bits_count(gb) / 8);
00447 }
00448
00449
00457 static QDM2SubPNode* qdm2_search_subpacket_type_in_list (QDM2SubPNode *list, int type)
00458 {
00459 while (list != NULL && list->packet != NULL) {
00460 if (list->packet->type == type)
00461 return list;
00462 list = list->next;
00463 }
00464 return NULL;
00465 }
00466
00467
00474 static void average_quantized_coeffs (QDM2Context *q)
00475 {
00476 int i, j, n, ch, sum;
00477
00478 n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;
00479
00480 for (ch = 0; ch < q->nb_channels; ch++)
00481 for (i = 0; i < n; i++) {
00482 sum = 0;
00483
00484 for (j = 0; j < 8; j++)
00485 sum += q->quantized_coeffs[ch][i][j];
00486
00487 sum /= 8;
00488 if (sum > 0)
00489 sum--;
00490
00491 for (j=0; j < 8; j++)
00492 q->quantized_coeffs[ch][i][j] = sum;
00493 }
00494 }
00495
00496
00504 static void build_sb_samples_from_noise (QDM2Context *q, int sb)
00505 {
00506 int ch, j;
00507
00508 FIX_NOISE_IDX(q->noise_idx);
00509
00510 if (!q->nb_channels)
00511 return;
00512
00513 for (ch = 0; ch < q->nb_channels; ch++)
00514 for (j = 0; j < 64; j++) {
00515 q->sb_samples[ch][j * 2][sb] = (int32_t)(f2i_scale * SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j] + .5);
00516 q->sb_samples[ch][j * 2 + 1][sb] = (int32_t)(f2i_scale * SB_DITHERING_NOISE(sb,q->noise_idx) * q->tone_level[ch][sb][j] + .5);
00517 }
00518 }
00519
00520
00529 static void fix_coding_method_array (int sb, int channels, sb_int8_array coding_method)
00530 {
00531 int j,k;
00532 int ch;
00533 int run, case_val;
00534 int switchtable[23] = {0,5,1,5,5,5,5,5,2,5,5,5,5,5,5,5,3,5,5,5,5,5,4};
00535
00536 for (ch = 0; ch < channels; ch++) {
00537 for (j = 0; j < 64; ) {
00538 if((coding_method[ch][sb][j] - 8) > 22) {
00539 run = 1;
00540 case_val = 8;
00541 } else {
00542 switch (switchtable[coding_method[ch][sb][j]-8]) {
00543 case 0: run = 10; case_val = 10; break;
00544 case 1: run = 1; case_val = 16; break;
00545 case 2: run = 5; case_val = 24; break;
00546 case 3: run = 3; case_val = 30; break;
00547 case 4: run = 1; case_val = 30; break;
00548 case 5: run = 1; case_val = 8; break;
00549 default: run = 1; case_val = 8; break;
00550 }
00551 }
00552 for (k = 0; k < run; k++)
00553 if (j + k < 128)
00554 if (coding_method[ch][sb + (j + k) / 64][(j + k) % 64] > coding_method[ch][sb][j])
00555 if (k > 0) {
00556 SAMPLES_NEEDED
00557
00558 memset(&coding_method[ch][sb][j + k], case_val, k * sizeof(int8_t));
00559 memset(&coding_method[ch][sb][j + k], case_val, 3 * sizeof(int8_t));
00560 }
00561 j += run;
00562 }
00563 }
00564 }
00565
00566
00574 static void fill_tone_level_array (QDM2Context *q, int flag)
00575 {
00576 int i, sb, ch, sb_used;
00577 int tmp, tab;
00578
00579
00580 if (q->nb_channels <= 0)
00581 return;
00582
00583 for (ch = 0; ch < q->nb_channels; ch++)
00584 for (sb = 0; sb < 30; sb++)
00585 for (i = 0; i < 8; i++) {
00586 if ((tab=coeff_per_sb_for_dequant[q->coeff_per_sb_select][sb]) < (last_coeff[q->coeff_per_sb_select] - 1))
00587 tmp = q->quantized_coeffs[ch][tab + 1][i] * dequant_table[q->coeff_per_sb_select][tab + 1][sb]+
00588 q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb];
00589 else
00590 tmp = q->quantized_coeffs[ch][tab][i] * dequant_table[q->coeff_per_sb_select][tab][sb];
00591 if(tmp < 0)
00592 tmp += 0xff;
00593 q->tone_level_idx_base[ch][sb][i] = (tmp / 256) & 0xff;
00594 }
00595
00596 sb_used = QDM2_SB_USED(q->sub_sampling);
00597
00598 if ((q->superblocktype_2_3 != 0) && !flag) {
00599 for (sb = 0; sb < sb_used; sb++)
00600 for (ch = 0; ch < q->nb_channels; ch++)
00601 for (i = 0; i < 64; i++) {
00602 q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];
00603 if (q->tone_level_idx[ch][sb][i] < 0)
00604 q->tone_level[ch][sb][i] = 0;
00605 else
00606 q->tone_level[ch][sb][i] = fft_tone_level_table[0][q->tone_level_idx[ch][sb][i] & 0x3f];
00607 }
00608 } else {
00609 tab = q->superblocktype_2_3 ? 0 : 1;
00610 for (sb = 0; sb < sb_used; sb++) {
00611 if ((sb >= 4) && (sb <= 23)) {
00612 for (ch = 0; ch < q->nb_channels; ch++)
00613 for (i = 0; i < 64; i++) {
00614 tmp = q->tone_level_idx_base[ch][sb][i / 8] -
00615 q->tone_level_idx_hi1[ch][sb / 8][i / 8][i % 8] -
00616 q->tone_level_idx_mid[ch][sb - 4][i / 8] -
00617 q->tone_level_idx_hi2[ch][sb - 4];
00618 q->tone_level_idx[ch][sb][i] = tmp & 0xff;
00619 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
00620 q->tone_level[ch][sb][i] = 0;
00621 else
00622 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
00623 }
00624 } else {
00625 if (sb > 4) {
00626 for (ch = 0; ch < q->nb_channels; ch++)
00627 for (i = 0; i < 64; i++) {
00628 tmp = q->tone_level_idx_base[ch][sb][i / 8] -
00629 q->tone_level_idx_hi1[ch][2][i / 8][i % 8] -
00630 q->tone_level_idx_hi2[ch][sb - 4];
00631 q->tone_level_idx[ch][sb][i] = tmp & 0xff;
00632 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
00633 q->tone_level[ch][sb][i] = 0;
00634 else
00635 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
00636 }
00637 } else {
00638 for (ch = 0; ch < q->nb_channels; ch++)
00639 for (i = 0; i < 64; i++) {
00640 tmp = q->tone_level_idx[ch][sb][i] = q->tone_level_idx_base[ch][sb][i / 8];
00641 if ((tmp < 0) || (!q->superblocktype_2_3 && !tmp))
00642 q->tone_level[ch][sb][i] = 0;
00643 else
00644 q->tone_level[ch][sb][i] = fft_tone_level_table[tab][tmp & 0x3f];
00645 }
00646 }
00647 }
00648 }
00649 }
00650
00651 return;
00652 }
00653
00654
00669 static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp,
00670 sb_int8_array coding_method, int nb_channels,
00671 int c, int superblocktype_2_3, int cm_table_select)
00672 {
00673 int ch, sb, j;
00674 int tmp, acc, esp_40, comp;
00675 int add1, add2, add3, add4;
00676 int64_t multres;
00677
00678
00679 if (nb_channels <= 0)
00680 return;
00681
00682 if (!superblocktype_2_3) {
00683
00684 SAMPLES_NEEDED
00685 for (ch = 0; ch < nb_channels; ch++)
00686 for (sb = 0; sb < 30; sb++) {
00687 for (j = 1; j < 64; j++) {
00688 add1 = tone_level_idx[ch][sb][j] - 10;
00689 if (add1 < 0)
00690 add1 = 0;
00691 add2 = add3 = add4 = 0;
00692 if (sb > 1) {
00693 add2 = tone_level_idx[ch][sb - 2][j] + tone_level_idx_offset_table[sb][0] - 6;
00694 if (add2 < 0)
00695 add2 = 0;
00696 }
00697 if (sb > 0) {
00698 add3 = tone_level_idx[ch][sb - 1][j] + tone_level_idx_offset_table[sb][1] - 6;
00699 if (add3 < 0)
00700 add3 = 0;
00701 }
00702 if (sb < 29) {
00703 add4 = tone_level_idx[ch][sb + 1][j] + tone_level_idx_offset_table[sb][3] - 6;
00704 if (add4 < 0)
00705 add4 = 0;
00706 }
00707 tmp = tone_level_idx[ch][sb][j + 1] * 2 - add4 - add3 - add2 - add1;
00708 if (tmp < 0)
00709 tmp = 0;
00710 tone_level_idx_temp[ch][sb][j + 1] = tmp & 0xff;
00711 }
00712 tone_level_idx_temp[ch][sb][0] = tone_level_idx_temp[ch][sb][1];
00713 }
00714 acc = 0;
00715 for (ch = 0; ch < nb_channels; ch++)
00716 for (sb = 0; sb < 30; sb++)
00717 for (j = 0; j < 64; j++)
00718 acc += tone_level_idx_temp[ch][sb][j];
00719 if (acc)
00720 tmp = c * 256 / (acc & 0xffff);
00721 multres = 0x66666667 * (acc * 10);
00722 esp_40 = (multres >> 32) / 8 + ((multres & 0xffffffff) >> 31);
00723 for (ch = 0; ch < nb_channels; ch++)
00724 for (sb = 0; sb < 30; sb++)
00725 for (j = 0; j < 64; j++) {
00726 comp = tone_level_idx_temp[ch][sb][j]* esp_40 * 10;
00727 if (comp < 0)
00728 comp += 0xff;
00729 comp /= 256;
00730 switch(sb) {
00731 case 0:
00732 if (comp < 30)
00733 comp = 30;
00734 comp += 15;
00735 break;
00736 case 1:
00737 if (comp < 24)
00738 comp = 24;
00739 comp += 10;
00740 break;
00741 case 2:
00742 case 3:
00743 case 4:
00744 if (comp < 16)
00745 comp = 16;
00746 }
00747 if (comp <= 5)
00748 tmp = 0;
00749 else if (comp <= 10)
00750 tmp = 10;
00751 else if (comp <= 16)
00752 tmp = 16;
00753 else if (comp <= 24)
00754 tmp = -1;
00755 else
00756 tmp = 0;
00757 coding_method[ch][sb][j] = ((tmp & 0xfffa) + 30 )& 0xff;
00758 }
00759 for (sb = 0; sb < 30; sb++)
00760 fix_coding_method_array(sb, nb_channels, coding_method);
00761 for (ch = 0; ch < nb_channels; ch++)
00762 for (sb = 0; sb < 30; sb++)
00763 for (j = 0; j < 64; j++)
00764 if (sb >= 10) {
00765 if (coding_method[ch][sb][j] < 10)
00766 coding_method[ch][sb][j] = 10;
00767 } else {
00768 if (sb >= 2) {
00769 if (coding_method[ch][sb][j] < 16)
00770 coding_method[ch][sb][j] = 16;
00771 } else {
00772 if (coding_method[ch][sb][j] < 30)
00773 coding_method[ch][sb][j] = 30;
00774 }
00775 }
00776 } else {
00777 for (ch = 0; ch < nb_channels; ch++)
00778 for (sb = 0; sb < 30; sb++)
00779 for (j = 0; j < 64; j++)
00780 coding_method[ch][sb][j] = coding_method_table[cm_table_select][sb];
00781 }
00782
00783 return;
00784 }
00785
00786
00798 static void synthfilt_build_sb_samples (QDM2Context *q, GetBitContext *gb, int length, int sb_min, int sb_max)
00799 {
00800 int sb, j, k, n, ch, run, channels;
00801 int joined_stereo, zero_encoding, chs;
00802 int type34_first;
00803 float type34_div = 0;
00804 float type34_predictor;
00805 float samples[10], sign_bits[16];
00806
00807 if (length == 0) {
00808
00809 for (sb=sb_min; sb < sb_max; sb++)
00810 build_sb_samples_from_noise (q, sb);
00811
00812 return;
00813 }
00814
00815 for (sb = sb_min; sb < sb_max; sb++) {
00816 FIX_NOISE_IDX(q->noise_idx);
00817
00818 channels = q->nb_channels;
00819
00820 if (q->nb_channels <= 1 || sb < 12)
00821 joined_stereo = 0;
00822 else if (sb >= 24)
00823 joined_stereo = 1;
00824 else
00825 joined_stereo = (BITS_LEFT(length,gb) >= 1) ? get_bits1 (gb) : 0;
00826
00827 if (joined_stereo) {
00828 if (BITS_LEFT(length,gb) >= 16)
00829 for (j = 0; j < 16; j++)
00830 sign_bits[j] = get_bits1 (gb);
00831
00832 for (j = 0; j < 64; j++)
00833 if (q->coding_method[1][sb][j] > q->coding_method[0][sb][j])
00834 q->coding_method[0][sb][j] = q->coding_method[1][sb][j];
00835
00836 fix_coding_method_array(sb, q->nb_channels, q->coding_method);
00837 channels = 1;
00838 }
00839
00840 for (ch = 0; ch < channels; ch++) {
00841 zero_encoding = (BITS_LEFT(length,gb) >= 1) ? get_bits1(gb) : 0;
00842 type34_predictor = 0.0;
00843 type34_first = 1;
00844
00845 for (j = 0; j < 128; ) {
00846 switch (q->coding_method[ch][sb][j / 2]) {
00847 case 8:
00848 if (BITS_LEFT(length,gb) >= 10) {
00849 if (zero_encoding) {
00850 for (k = 0; k < 5; k++) {
00851 if ((j + 2 * k) >= 128)
00852 break;
00853 samples[2 * k] = get_bits1(gb) ? dequant_1bit[joined_stereo][2 * get_bits1(gb)] : 0;
00854 }
00855 } else {
00856 n = get_bits(gb, 8);
00857 for (k = 0; k < 5; k++)
00858 samples[2 * k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
00859 }
00860 for (k = 0; k < 5; k++)
00861 samples[2 * k + 1] = SB_DITHERING_NOISE(sb,q->noise_idx);
00862 } else {
00863 for (k = 0; k < 10; k++)
00864 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
00865 }
00866 run = 10;
00867 break;
00868
00869 case 10:
00870 if (BITS_LEFT(length,gb) >= 1) {
00871 float f = 0.81;
00872
00873 if (get_bits1(gb))
00874 f = -f;
00875 f -= noise_samples[((sb + 1) * (j +5 * ch + 1)) & 127] * 9.0 / 40.0;
00876 samples[0] = f;
00877 } else {
00878 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
00879 }
00880 run = 1;
00881 break;
00882
00883 case 16:
00884 if (BITS_LEFT(length,gb) >= 10) {
00885 if (zero_encoding) {
00886 for (k = 0; k < 5; k++) {
00887 if ((j + k) >= 128)
00888 break;
00889 samples[k] = (get_bits1(gb) == 0) ? 0 : dequant_1bit[joined_stereo][2 * get_bits1(gb)];
00890 }
00891 } else {
00892 n = get_bits (gb, 8);
00893 for (k = 0; k < 5; k++)
00894 samples[k] = dequant_1bit[joined_stereo][random_dequant_index[n][k]];
00895 }
00896 } else {
00897 for (k = 0; k < 5; k++)
00898 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
00899 }
00900 run = 5;
00901 break;
00902
00903 case 24:
00904 if (BITS_LEFT(length,gb) >= 7) {
00905 n = get_bits(gb, 7);
00906 for (k = 0; k < 3; k++)
00907 samples[k] = (random_dequant_type24[n][k] - 2.0) * 0.5;
00908 } else {
00909 for (k = 0; k < 3; k++)
00910 samples[k] = SB_DITHERING_NOISE(sb,q->noise_idx);
00911 }
00912 run = 3;
00913 break;
00914
00915 case 30:
00916 if (BITS_LEFT(length,gb) >= 4)
00917 samples[0] = type30_dequant[qdm2_get_vlc(gb, &vlc_tab_type30, 0, 1)];
00918 else
00919 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
00920
00921 run = 1;
00922 break;
00923
00924 case 34:
00925 if (BITS_LEFT(length,gb) >= 7) {
00926 if (type34_first) {
00927 type34_div = (float)(1 << get_bits(gb, 2));
00928 samples[0] = ((float)get_bits(gb, 5) - 16.0) / 15.0;
00929 type34_predictor = samples[0];
00930 type34_first = 0;
00931 } else {
00932 samples[0] = type34_delta[qdm2_get_vlc(gb, &vlc_tab_type34, 0, 1)] / type34_div + type34_predictor;
00933 type34_predictor = samples[0];
00934 }
00935 } else {
00936 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
00937 }
00938 run = 1;
00939 break;
00940
00941 default:
00942 samples[0] = SB_DITHERING_NOISE(sb,q->noise_idx);
00943 run = 1;
00944 break;
00945 }
00946
00947 if (joined_stereo) {
00948 float tmp[10][MPA_MAX_CHANNELS];
00949
00950 for (k = 0; k < run; k++) {
00951 tmp[k][0] = samples[k];
00952 tmp[k][1] = (sign_bits[(j + k) / 8]) ? -samples[k] : samples[k];
00953 }
00954 for (chs = 0; chs < q->nb_channels; chs++)
00955 for (k = 0; k < run; k++)
00956 if ((j + k) < 128)
00957 q->sb_samples[chs][j + k][sb] = (int32_t)(f2i_scale * q->tone_level[chs][sb][((j + k)/2)] * tmp[k][chs] + .5);
00958 } else {
00959 for (k = 0; k < run; k++)
00960 if ((j + k) < 128)
00961 q->sb_samples[ch][j + k][sb] = (int32_t)(f2i_scale * q->tone_level[ch][sb][(j + k)/2] * samples[k] + .5);
00962 }
00963
00964 j += run;
00965 }
00966 }
00967 }
00968 }
00969
00970
00981 static void init_quantized_coeffs_elem0 (int8_t *quantized_coeffs, GetBitContext *gb, int length)
00982 {
00983 int i, k, run, level, diff;
00984
00985 if (BITS_LEFT(length,gb) < 16)
00986 return;
00987 level = qdm2_get_vlc(gb, &vlc_tab_level, 0, 2);
00988
00989 quantized_coeffs[0] = level;
00990
00991 for (i = 0; i < 7; ) {
00992 if (BITS_LEFT(length,gb) < 16)
00993 break;
00994 run = qdm2_get_vlc(gb, &vlc_tab_run, 0, 1) + 1;
00995
00996 if (BITS_LEFT(length,gb) < 16)
00997 break;
00998 diff = qdm2_get_se_vlc(&vlc_tab_diff, gb, 2);
00999
01000 for (k = 1; k <= run; k++)
01001 quantized_coeffs[i + k] = (level + ((k * diff) / run));
01002
01003 level += diff;
01004 i += run;
01005 }
01006 }
01007
01008
01018 static void init_tone_level_dequantization (QDM2Context *q, GetBitContext *gb, int length)
01019 {
01020 int sb, j, k, n, ch;
01021
01022 for (ch = 0; ch < q->nb_channels; ch++) {
01023 init_quantized_coeffs_elem0(q->quantized_coeffs[ch][0], gb, length);
01024
01025 if (BITS_LEFT(length,gb) < 16) {
01026 memset(q->quantized_coeffs[ch][0], 0, 8);
01027 break;
01028 }
01029 }
01030
01031 n = q->sub_sampling + 1;
01032
01033 for (sb = 0; sb < n; sb++)
01034 for (ch = 0; ch < q->nb_channels; ch++)
01035 for (j = 0; j < 8; j++) {
01036 if (BITS_LEFT(length,gb) < 1)
01037 break;
01038 if (get_bits1(gb)) {
01039 for (k=0; k < 8; k++) {
01040 if (BITS_LEFT(length,gb) < 16)
01041 break;
01042 q->tone_level_idx_hi1[ch][sb][j][k] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi1, 0, 2);
01043 }
01044 } else {
01045 for (k=0; k < 8; k++)
01046 q->tone_level_idx_hi1[ch][sb][j][k] = 0;
01047 }
01048 }
01049
01050 n = QDM2_SB_USED(q->sub_sampling) - 4;
01051
01052 for (sb = 0; sb < n; sb++)
01053 for (ch = 0; ch < q->nb_channels; ch++) {
01054 if (BITS_LEFT(length,gb) < 16)
01055 break;
01056 q->tone_level_idx_hi2[ch][sb] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_hi2, 0, 2);
01057 if (sb > 19)
01058 q->tone_level_idx_hi2[ch][sb] -= 16;
01059 else
01060 for (j = 0; j < 8; j++)
01061 q->tone_level_idx_mid[ch][sb][j] = -16;
01062 }
01063
01064 n = QDM2_SB_USED(q->sub_sampling) - 5;
01065
01066 for (sb = 0; sb < n; sb++)
01067 for (ch = 0; ch < q->nb_channels; ch++)
01068 for (j = 0; j < 8; j++) {
01069 if (BITS_LEFT(length,gb) < 16)
01070 break;
01071 q->tone_level_idx_mid[ch][sb][j] = qdm2_get_vlc(gb, &vlc_tab_tone_level_idx_mid, 0, 2) - 32;
01072 }
01073 }
01074
01081 static void process_subpacket_9 (QDM2Context *q, QDM2SubPNode *node)
01082 {
01083 GetBitContext gb;
01084 int i, j, k, n, ch, run, level, diff;
01085
01086 init_get_bits(&gb, node->packet->data, node->packet->size*8);
01087
01088 n = coeff_per_sb_for_avg[q->coeff_per_sb_select][QDM2_SB_USED(q->sub_sampling) - 1] + 1;
01089
01090 for (i = 1; i < n; i++)
01091 for (ch=0; ch < q->nb_channels; ch++) {
01092 level = qdm2_get_vlc(&gb, &vlc_tab_level, 0, 2);
01093 q->quantized_coeffs[ch][i][0] = level;
01094
01095 for (j = 0; j < (8 - 1); ) {
01096 run = qdm2_get_vlc(&gb, &vlc_tab_run, 0, 1) + 1;
01097 diff = qdm2_get_se_vlc(&vlc_tab_diff, &gb, 2);
01098
01099 for (k = 1; k <= run; k++)
01100 q->quantized_coeffs[ch][i][j + k] = (level + ((k*diff) / run));
01101
01102 level += diff;
01103 j += run;
01104 }
01105 }
01106
01107 for (ch = 0; ch < q->nb_channels; ch++)
01108 for (i = 0; i < 8; i++)
01109 q->quantized_coeffs[ch][0][i] = 0;
01110 }
01111
01112
01120 static void process_subpacket_10 (QDM2Context *q, QDM2SubPNode *node, int length)
01121 {
01122 GetBitContext gb;
01123
01124 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
01125
01126 if (length != 0) {
01127 init_tone_level_dequantization(q, &gb, length);
01128 fill_tone_level_array(q, 1);
01129 } else {
01130 fill_tone_level_array(q, 0);
01131 }
01132 }
01133
01134
01142 static void process_subpacket_11 (QDM2Context *q, QDM2SubPNode *node, int length)
01143 {
01144 GetBitContext gb;
01145
01146 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
01147 if (length >= 32) {
01148 int c = get_bits (&gb, 13);
01149
01150 if (c > 3)
01151 fill_coding_method_array (q->tone_level_idx, q->tone_level_idx_temp, q->coding_method,
01152 q->nb_channels, 8*c, q->superblocktype_2_3, q->cm_table_select);
01153 }
01154
01155 synthfilt_build_sb_samples(q, &gb, length, 0, 8);
01156 }
01157
01158
01166 static void process_subpacket_12 (QDM2Context *q, QDM2SubPNode *node, int length)
01167 {
01168 GetBitContext gb;
01169
01170 init_get_bits(&gb, ((node == NULL) ? empty_buffer : node->packet->data), ((node == NULL) ? 0 : node->packet->size*8));
01171 synthfilt_build_sb_samples(q, &gb, length, 8, QDM2_SB_USED(q->sub_sampling));
01172 }
01173
01174
01175
01176
01177
01178
01179
01180 static void process_synthesis_subpackets (QDM2Context *q, QDM2SubPNode *list)
01181 {
01182 QDM2SubPNode *nodes[4];
01183
01184 nodes[0] = qdm2_search_subpacket_type_in_list(list, 9);
01185 if (nodes[0] != NULL)
01186 process_subpacket_9(q, nodes[0]);
01187
01188 nodes[1] = qdm2_search_subpacket_type_in_list(list, 10);
01189 if (nodes[1] != NULL)
01190 process_subpacket_10(q, nodes[1], nodes[1]->packet->size << 3);
01191 else
01192 process_subpacket_10(q, NULL, 0);
01193
01194 nodes[2] = qdm2_search_subpacket_type_in_list(list, 11);
01195 if (nodes[0] != NULL && nodes[1] != NULL && nodes[2] != NULL)
01196 process_subpacket_11(q, nodes[2], (nodes[2]->packet->size << 3));
01197 else
01198 process_subpacket_11(q, NULL, 0);
01199
01200 nodes[3] = qdm2_search_subpacket_type_in_list(list, 12);
01201 if (nodes[0] != NULL && nodes[1] != NULL && nodes[3] != NULL)
01202 process_subpacket_12(q, nodes[3], (nodes[3]->packet->size << 3));
01203 else
01204 process_subpacket_12(q, NULL, 0);
01205 }
01206
01207
01208
01209
01210
01211
01212
01213 static void qdm2_decode_super_block (QDM2Context *q)
01214 {
01215 GetBitContext gb;
01216 QDM2SubPacket header, *packet;
01217 int i, packet_bytes, sub_packet_size, sub_packets_D;
01218 unsigned int next_index = 0;
01219
01220 memset(q->tone_level_idx_hi1, 0, sizeof(q->tone_level_idx_hi1));
01221 memset(q->tone_level_idx_mid, 0, sizeof(q->tone_level_idx_mid));
01222 memset(q->tone_level_idx_hi2, 0, sizeof(q->tone_level_idx_hi2));
01223
01224 q->sub_packets_B = 0;
01225 sub_packets_D = 0;
01226
01227 average_quantized_coeffs(q);
01228
01229 init_get_bits(&gb, q->compressed_data, q->compressed_size*8);
01230 qdm2_decode_sub_packet_header(&gb, &header);
01231
01232 if (header.type < 2 || header.type >= 8) {
01233 q->has_errors = 1;
01234 av_log(NULL,AV_LOG_ERROR,"bad superblock type\n");
01235 return;
01236 }
01237
01238 q->superblocktype_2_3 = (header.type == 2 || header.type == 3);
01239 packet_bytes = (q->compressed_size - get_bits_count(&gb) / 8);
01240
01241 init_get_bits(&gb, header.data, header.size*8);
01242
01243 if (header.type == 2 || header.type == 4 || header.type == 5) {
01244 int csum = 257 * get_bits(&gb, 8) + 2 * get_bits(&gb, 8);
01245
01246 csum = qdm2_packet_checksum(q->compressed_data, q->checksum_size, csum);
01247
01248 if (csum != 0) {
01249 q->has_errors = 1;
01250 av_log(NULL,AV_LOG_ERROR,"bad packet checksum\n");
01251 return;
01252 }
01253 }
01254
01255 q->sub_packet_list_B[0].packet = NULL;
01256 q->sub_packet_list_D[0].packet = NULL;
01257
01258 for (i = 0; i < 6; i++)
01259 if (--q->fft_level_exp[i] < 0)
01260 q->fft_level_exp[i] = 0;
01261
01262 for (i = 0; packet_bytes > 0; i++) {
01263 int j;
01264
01265 q->sub_packet_list_A[i].next = NULL;
01266
01267 if (i > 0) {
01268 q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];
01269
01270
01271 init_get_bits(&gb, header.data, header.size*8);
01272 skip_bits(&gb, next_index*8);
01273
01274 if (next_index >= header.size)
01275 break;
01276 }
01277
01278
01279 packet = &q->sub_packets[i];
01280 qdm2_decode_sub_packet_header(&gb, packet);
01281 next_index = packet->size + get_bits_count(&gb) / 8;
01282 sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
01283
01284 if (packet->type == 0)
01285 break;
01286
01287 if (sub_packet_size > packet_bytes) {
01288 if (packet->type != 10 && packet->type != 11 && packet->type != 12)
01289 break;
01290 packet->size += packet_bytes - sub_packet_size;
01291 }
01292
01293 packet_bytes -= sub_packet_size;
01294
01295
01296 q->sub_packet_list_A[i].packet = packet;
01297
01298
01299 if (packet->type == 8) {
01300 SAMPLES_NEEDED_2("packet type 8");
01301 return;
01302 } else if (packet->type >= 9 && packet->type <= 12) {
01303
01304 QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet);
01305 } else if (packet->type == 13) {
01306 for (j = 0; j < 6; j++)
01307 q->fft_level_exp[j] = get_bits(&gb, 6);
01308 } else if (packet->type == 14) {
01309 for (j = 0; j < 6; j++)
01310 q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2);
01311 } else if (packet->type == 15) {
01312 SAMPLES_NEEDED_2("packet type 15")
01313 return;
01314 } else if (packet->type >= 16 && packet->type < 48 && !fft_subpackets[packet->type - 16]) {
01315
01316 QDM2_LIST_ADD(q->sub_packet_list_B, q->sub_packets_B, packet);
01317 }
01318 }
01319
01320
01321 if (q->sub_packet_list_D[0].packet != NULL) {
01322 process_synthesis_subpackets(q, q->sub_packet_list_D);
01323 q->do_synth_filter = 1;
01324 } else if (q->do_synth_filter) {
01325 process_subpacket_10(q, NULL, 0);
01326 process_subpacket_11(q, NULL, 0);
01327 process_subpacket_12(q, NULL, 0);
01328 }
01329
01330 }
01331
01332
01333 static void qdm2_fft_init_coefficient (QDM2Context *q, int sub_packet,
01334 int offset, int duration, int channel,
01335 int exp, int phase)
01336 {
01337 if (q->fft_coefs_min_index[duration] < 0)
01338 q->fft_coefs_min_index[duration] = q->fft_coefs_index;
01339
01340 q->fft_coefs[q->fft_coefs_index].sub_packet = ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
01341 q->fft_coefs[q->fft_coefs_index].channel = channel;
01342 q->fft_coefs[q->fft_coefs_index].offset = offset;
01343 q->fft_coefs[q->fft_coefs_index].exp = exp;
01344 q->fft_coefs[q->fft_coefs_index].phase = phase;
01345 q->fft_coefs_index++;
01346 }
01347
01348
01349 static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *gb, int b)
01350 {
01351 int channel, stereo, phase, exp;
01352 int local_int_4, local_int_8, stereo_phase, local_int_10;
01353 int local_int_14, stereo_exp, local_int_20, local_int_28;
01354 int n, offset;
01355
01356 local_int_4 = 0;
01357 local_int_28 = 0;
01358 local_int_20 = 2;
01359 local_int_8 = (4 - duration);
01360 local_int_10 = 1 << (q->group_order - duration - 1);
01361 offset = 1;
01362
01363 while (1) {
01364 if (q->superblocktype_2_3) {
01365 while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
01366 offset = 1;
01367 if (n == 0) {
01368 local_int_4 += local_int_10;
01369 local_int_28 += (1 << local_int_8);
01370 } else {
01371 local_int_4 += 8*local_int_10;
01372 local_int_28 += (8 << local_int_8);
01373 }
01374 }
01375 offset += (n - 2);
01376 } else {
01377 offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
01378 while (offset >= (local_int_10 - 1)) {
01379 offset += (1 - (local_int_10 - 1));
01380 local_int_4 += local_int_10;
01381 local_int_28 += (1 << local_int_8);
01382 }
01383 }
01384
01385 if (local_int_4 >= q->group_size)
01386 return;
01387
01388 local_int_14 = (offset >> local_int_8);
01389
01390 if (q->nb_channels > 1) {
01391 channel = get_bits1(gb);
01392 stereo = get_bits1(gb);
01393 } else {
01394 channel = 0;
01395 stereo = 0;
01396 }
01397
01398 exp = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
01399 exp += q->fft_level_exp[fft_level_index_table[local_int_14]];
01400 exp = (exp < 0) ? 0 : exp;
01401
01402 phase = get_bits(gb, 3);
01403 stereo_exp = 0;
01404 stereo_phase = 0;
01405
01406 if (stereo) {
01407 stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
01408 stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));
01409 if (stereo_phase < 0)
01410 stereo_phase += 8;
01411 }
01412
01413 if (q->frequency_range > (local_int_14 + 1)) {
01414 int sub_packet = (local_int_20 + local_int_28);
01415
01416 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, channel, exp, phase);
01417 if (stereo)
01418 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, (1 - channel), stereo_exp, stereo_phase);
01419 }
01420
01421 offset++;
01422 }
01423 }
01424
01425
01426 static void qdm2_decode_fft_packets (QDM2Context *q)
01427 {
01428 int i, j, min, max, value, type, unknown_flag;
01429 GetBitContext gb;
01430
01431 if (q->sub_packet_list_B[0].packet == NULL)
01432 return;
01433
01434
01435 q->fft_coefs_index = 0;
01436 for (i=0; i < 5; i++)
01437 q->fft_coefs_min_index[i] = -1;
01438
01439
01440 for (i = 0, max = 256; i < q->sub_packets_B; i++) {
01441 QDM2SubPacket *packet;
01442
01443
01444 for (j = 0, min = 0, packet = NULL; j < q->sub_packets_B; j++) {
01445 value = q->sub_packet_list_B[j].packet->type;
01446 if (value > min && value < max) {
01447 min = value;
01448 packet = q->sub_packet_list_B[j].packet;
01449 }
01450 }
01451
01452 max = min;
01453
01454
01455 if (i == 0 && (packet->type < 16 || packet->type >= 48 || fft_subpackets[packet->type - 16]))
01456 return;
01457
01458
01459 init_get_bits (&gb, packet->data, packet->size*8);
01460
01461 if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
01462 unknown_flag = 1;
01463 else
01464 unknown_flag = 0;
01465
01466 type = packet->type;
01467
01468 if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) {
01469 int duration = q->sub_sampling + 5 - (type & 15);
01470
01471 if (duration >= 0 && duration < 4)
01472 qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);
01473 } else if (type == 31) {
01474 for (j=0; j < 4; j++)
01475 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
01476 } else if (type == 46) {
01477 for (j=0; j < 6; j++)
01478 q->fft_level_exp[j] = get_bits(&gb, 6);
01479 for (j=0; j < 4; j++)
01480 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
01481 }
01482 }
01483
01484
01485 for (i = 0, j = -1; i < 5; i++)
01486 if (q->fft_coefs_min_index[i] >= 0) {
01487 if (j >= 0)
01488 q->fft_coefs_max_index[j] = q->fft_coefs_min_index[i];
01489 j = i;
01490 }
01491 if (j >= 0)
01492 q->fft_coefs_max_index[j] = q->fft_coefs_index;
01493 }
01494
01495
01496 static void qdm2_fft_generate_tone (QDM2Context *q, FFTTone *tone)
01497 {
01498 float level, f[6];
01499 int i;
01500 QDM2Complex c;
01501 const double iscale = 2.0*M_PI / 512.0;
01502
01503 tone->phase += tone->phase_shift;
01504
01505
01506 level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;
01507 c.im = level * sin(tone->phase*iscale);
01508 c.re = level * cos(tone->phase*iscale);
01509
01510
01511 if (tone->duration >= 3 || tone->cutoff >= 3) {
01512 tone->samples_im[0] += c.im;
01513 tone->samples_re[0] += c.re;
01514 tone->samples_im[1] -= c.im;
01515 tone->samples_re[1] -= c.re;
01516 } else {
01517 f[1] = -tone->table[4];
01518 f[0] = tone->table[3] - tone->table[0];
01519 f[2] = 1.0 - tone->table[2] - tone->table[3];
01520 f[3] = tone->table[1] + tone->table[4] - 1.0;
01521 f[4] = tone->table[0] - tone->table[1];
01522 f[5] = tone->table[2];
01523 for (i = 0; i < 2; i++) {
01524 tone->samples_re[fft_cutoff_index_table[tone->cutoff][i]] += c.re * f[i];
01525 tone->samples_im[fft_cutoff_index_table[tone->cutoff][i]] += c.im *((tone->cutoff <= i) ? -f[i] : f[i]);
01526 }
01527 for (i = 0; i < 4; i++) {
01528 tone->samples_re[i] += c.re * f[i+2];
01529 tone->samples_im[i] += c.im * f[i+2];
01530 }
01531 }
01532
01533
01534 if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {
01535 memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));
01536 q->fft_tone_end = (q->fft_tone_end + 1) % 1000;
01537 }
01538 }
01539
01540
01541 static void qdm2_fft_tone_synthesizer (QDM2Context *q, int sub_packet)
01542 {
01543 int i, j, ch;
01544 const double iscale = 0.25 * M_PI;
01545
01546 for (ch = 0; ch < q->channels; ch++) {
01547 memset(q->fft.samples_im[ch], 0, q->fft_size * sizeof(float));
01548 memset(q->fft.samples_re[ch], 0, q->fft_size * sizeof(float));
01549 }
01550
01551
01552
01553 if (q->fft_coefs_min_index[4] >= 0)
01554 for (i = q->fft_coefs_min_index[4]; i < q->fft_coefs_max_index[4]; i++) {
01555 float level;
01556 QDM2Complex c;
01557
01558 if (q->fft_coefs[i].sub_packet != sub_packet)
01559 break;
01560
01561 ch = (q->channels == 1) ? 0 : q->fft_coefs[i].channel;
01562 level = (q->fft_coefs[i].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[i].exp & 63];
01563
01564 c.re = level * cos(q->fft_coefs[i].phase * iscale);
01565 c.im = level * sin(q->fft_coefs[i].phase * iscale);
01566 q->fft.samples_re[ch][q->fft_coefs[i].offset + 0] += c.re;
01567 q->fft.samples_im[ch][q->fft_coefs[i].offset + 0] += c.im;
01568 q->fft.samples_re[ch][q->fft_coefs[i].offset + 1] -= c.re;
01569 q->fft.samples_im[ch][q->fft_coefs[i].offset + 1] -= c.im;
01570 }
01571
01572
01573 for (i = q->fft_tone_end; i != q->fft_tone_start; ) {
01574 qdm2_fft_generate_tone(q, &q->fft_tones[q->fft_tone_start]);
01575 q->fft_tone_start = (q->fft_tone_start + 1) % 1000;
01576 }
01577
01578
01579 for (i = 0; i < 4; i++)
01580 if (q->fft_coefs_min_index[i] >= 0) {
01581 for (j = q->fft_coefs_min_index[i]; j < q->fft_coefs_max_index[i]; j++) {
01582 int offset, four_i;
01583 FFTTone tone;
01584
01585 if (q->fft_coefs[j].sub_packet != sub_packet)
01586 break;
01587
01588 four_i = (4 - i);
01589 offset = q->fft_coefs[j].offset >> four_i;
01590 ch = (q->channels == 1) ? 0 : q->fft_coefs[j].channel;
01591
01592 if (offset < q->frequency_range) {
01593 if (offset < 2)
01594 tone.cutoff = offset;
01595 else
01596 tone.cutoff = (offset >= 60) ? 3 : 2;
01597
01598 tone.level = (q->fft_coefs[j].exp < 0) ? 0.0 : fft_tone_level_table[q->superblocktype_2_3 ? 0 : 1][q->fft_coefs[j].exp & 63];
01599 tone.samples_im = &q->fft.samples_im[ch][offset];
01600 tone.samples_re = &q->fft.samples_re[ch][offset];
01601 tone.table = fft_tone_sample_table[i][q->fft_coefs[j].offset - (offset << four_i)];
01602 tone.phase = 64 * q->fft_coefs[j].phase - (offset << 8) - 128;
01603 tone.phase_shift = (2 * q->fft_coefs[j].offset + 1) << (7 - four_i);
01604 tone.duration = i;
01605 tone.time_index = 0;
01606
01607 qdm2_fft_generate_tone(q, &tone);
01608 }
01609 }
01610 q->fft_coefs_min_index[i] = j;
01611 }
01612 }
01613
01614
01615 static void qdm2_calculate_fft (QDM2Context *q, int channel, int sub_packet)
01616 {
01617 const int n = 1 << (q->fft_order - 1);
01618 const int n2 = n >> 1;
01619 const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.25f : 0.50f;
01620 float c, s, f0, f1, f2, f3;
01621 int i, j;
01622
01623
01624 for (i=1; i < n2; i++) {
01625 j = (n - i);
01626 c = q->exptab[i].re;
01627 s = -q->exptab[i].im;
01628 f0 = (q->fft.samples_re[channel][i] - q->fft.samples_re[channel][j]) * gain;
01629 f1 = (q->fft.samples_im[channel][i] + q->fft.samples_im[channel][j]) * gain;
01630 f2 = (q->fft.samples_re[channel][i] + q->fft.samples_re[channel][j]) * gain;
01631 f3 = (q->fft.samples_im[channel][i] - q->fft.samples_im[channel][j]) * gain;
01632 q->fft.complex[i].re = s * f0 - c * f1 + f2;
01633 q->fft.complex[i].im = c * f0 + s * f1 + f3;
01634 q->fft.complex[j].re = -s * f0 + c * f1 + f2;
01635 q->fft.complex[j].im = c * f0 + s * f1 - f3;
01636 }
01637
01638 q->fft.complex[ 0].re = q->fft.samples_re[channel][ 0] * gain * 2.0;
01639 q->fft.complex[ 0].im = q->fft.samples_re[channel][ 0] * gain * 2.0;
01640 q->fft.complex[n2].re = q->fft.samples_re[channel][n2] * gain * 2.0;
01641 q->fft.complex[n2].im = -q->fft.samples_im[channel][n2] * gain * 2.0;
01642
01643 ff_fft_permute(&q->fft_ctx, (FFTComplex *) q->fft.complex);
01644 ff_fft_calc (&q->fft_ctx, (FFTComplex *) q->fft.complex);
01645
01646 for (i = 0; i < ((q->fft_frame_size + 15) & ~15); i++)
01647 q->output_buffer[q->channels * i + channel] += ((float *) q->fft.complex)[i];
01648 }
01649
01650
01655 static void qdm2_synthesis_filter (QDM2Context *q, int index)
01656 {
01657 OUT_INT samples[MPA_MAX_CHANNELS * MPA_FRAME_SIZE];
01658 int i, k, ch, sb_used, sub_sampling, dither_state = 0;
01659
01660
01661 sb_used = QDM2_SB_USED(q->sub_sampling);
01662
01663 for (ch = 0; ch < q->channels; ch++)
01664 for (i = 0; i < 8; i++)
01665 for (k=sb_used; k < SBLIMIT; k++)
01666 q->sb_samples[ch][(8 * index) + i][k] = 0;
01667
01668 for (ch = 0; ch < q->nb_channels; ch++) {
01669 OUT_INT *samples_ptr = samples + ch;
01670
01671 for (i = 0; i < 8; i++) {
01672 ff_mpa_synth_filter(q->synth_buf[ch], &(q->synth_buf_offset[ch]),
01673 mpa_window, &dither_state,
01674 samples_ptr, q->nb_channels,
01675 q->sb_samples[ch][(8 * index) + i]);
01676 samples_ptr += 32 * q->nb_channels;
01677 }
01678 }
01679
01680
01681 sub_sampling = (4 >> q->sub_sampling);
01682
01683 for (ch = 0; ch < q->channels; ch++)
01684 for (i = 0; i < q->frame_size; i++)
01685 q->output_buffer[q->channels * i + ch] += (float)(samples[q->nb_channels * sub_sampling * i + ch] >> (sizeof(OUT_INT)*8-16));
01686 }
01687
01688
01694 static void qdm2_init(QDM2Context *q) {
01695 static int inited = 0;
01696
01697 if (inited != 0)
01698 return;
01699 inited = 1;
01700
01701 qdm2_init_vlc();
01702 ff_mpa_synth_init(mpa_window);
01703 softclip_table_init();
01704 rnd_table_init();
01705 init_noise_samples();
01706
01707 av_log(NULL, AV_LOG_DEBUG, "init done\n");
01708 }
01709
01710
01711 #if 0
01712 static void dump_context(QDM2Context *q)
01713 {
01714 int i;
01715 #define PRINT(a,b) av_log(NULL,AV_LOG_DEBUG," %s = %d\n", a, b);
01716 PRINT("compressed_data",q->compressed_data);
01717 PRINT("compressed_size",q->compressed_size);
01718 PRINT("frame_size",q->frame_size);
01719 PRINT("checksum_size",q->checksum_size);
01720 PRINT("channels",q->channels);
01721 PRINT("nb_channels",q->nb_channels);
01722 PRINT("fft_frame_size",q->fft_frame_size);
01723 PRINT("fft_size",q->fft_size);
01724 PRINT("sub_sampling",q->sub_sampling);
01725 PRINT("fft_order",q->fft_order);
01726 PRINT("group_order",q->group_order);
01727 PRINT("group_size",q->group_size);
01728 PRINT("sub_packet",q->sub_packet);
01729 PRINT("frequency_range",q->frequency_range);
01730 PRINT("has_errors",q->has_errors);
01731 PRINT("fft_tone_end",q->fft_tone_end);
01732 PRINT("fft_tone_start",q->fft_tone_start);
01733 PRINT("fft_coefs_index",q->fft_coefs_index);
01734 PRINT("coeff_per_sb_select",q->coeff_per_sb_select);
01735 PRINT("cm_table_select",q->cm_table_select);
01736 PRINT("noise_idx",q->noise_idx);
01737
01738 for (i = q->fft_tone_start; i < q->fft_tone_end; i++)
01739 {
01740 FFTTone *t = &q->fft_tones[i];
01741
01742 av_log(NULL,AV_LOG_DEBUG,"Tone (%d) dump:\n", i);
01743 av_log(NULL,AV_LOG_DEBUG," level = %f\n", t->level);
01744
01745 PRINT(" phase", t->phase);
01746 PRINT(" phase_shift", t->phase_shift);
01747 PRINT(" duration", t->duration);
01748 PRINT(" samples_im", t->samples_im);
01749 PRINT(" samples_re", t->samples_re);
01750 PRINT(" table", t->table);
01751 }
01752
01753 }
01754 #endif
01755
01756
01760 static int qdm2_decode_init(AVCodecContext *avctx)
01761 {
01762 QDM2Context *s = avctx->priv_data;
01763 uint8_t *extradata;
01764 int extradata_size;
01765 int tmp_val, tmp, size;
01766 int i;
01767 float alpha;
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803 if (!avctx->extradata || (avctx->extradata_size < 48)) {
01804 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
01805 return -1;
01806 }
01807
01808 extradata = avctx->extradata;
01809 extradata_size = avctx->extradata_size;
01810
01811 while (extradata_size > 7) {
01812 if (!memcmp(extradata, "frmaQDM", 7))
01813 break;
01814 extradata++;
01815 extradata_size--;
01816 }
01817
01818 if (extradata_size < 12) {
01819 av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
01820 extradata_size);
01821 return -1;
01822 }
01823
01824 if (memcmp(extradata, "frmaQDM", 7)) {
01825 av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");
01826 return -1;
01827 }
01828
01829 if (extradata[7] == 'C') {
01830
01831 av_log(avctx, AV_LOG_ERROR, "stream is QDMC version 1, which is not supported\n");
01832 return -1;
01833 }
01834
01835 extradata += 8;
01836 extradata_size -= 8;
01837
01838 size = AV_RB32(extradata);
01839
01840 if(size > extradata_size){
01841 av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
01842 extradata_size, size);
01843 return -1;
01844 }
01845
01846 extradata += 4;
01847 av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
01848 if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {
01849 av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
01850 return -1;
01851 }
01852
01853 extradata += 8;
01854
01855 avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata);
01856 extradata += 4;
01857
01858 avctx->sample_rate = AV_RB32(extradata);
01859 extradata += 4;
01860
01861 avctx->bit_rate = AV_RB32(extradata);
01862 extradata += 4;
01863
01864 s->group_size = AV_RB32(extradata);
01865 extradata += 4;
01866
01867 s->fft_size = AV_RB32(extradata);
01868 extradata += 4;
01869
01870 s->checksum_size = AV_RB32(extradata);
01871 extradata += 4;
01872
01873 s->fft_order = av_log2(s->fft_size) + 1;
01874 s->fft_frame_size = 2 * s->fft_size;
01875
01876
01877 s->group_order = av_log2(s->group_size) + 1;
01878 s->frame_size = s->group_size / 16;
01879
01880 s->sub_sampling = s->fft_order - 7;
01881 s->frequency_range = 255 / (1 << (2 - s->sub_sampling));
01882
01883 switch ((s->sub_sampling * 2 + s->channels - 1)) {
01884 case 0: tmp = 40; break;
01885 case 1: tmp = 48; break;
01886 case 2: tmp = 56; break;
01887 case 3: tmp = 72; break;
01888 case 4: tmp = 80; break;
01889 case 5: tmp = 100;break;
01890 default: tmp=s->sub_sampling; break;
01891 }
01892 tmp_val = 0;
01893 if ((tmp * 1000) < avctx->bit_rate) tmp_val = 1;
01894 if ((tmp * 1440) < avctx->bit_rate) tmp_val = 2;
01895 if ((tmp * 1760) < avctx->bit_rate) tmp_val = 3;
01896 if ((tmp * 2240) < avctx->bit_rate) tmp_val = 4;
01897 s->cm_table_select = tmp_val;
01898
01899 if (s->sub_sampling == 0)
01900 tmp = 7999;
01901 else
01902 tmp = ((-(s->sub_sampling -1)) & 8000) + 20000;
01903
01904
01905
01906
01907
01908 if (tmp < 8000)
01909 s->coeff_per_sb_select = 0;
01910 else if (tmp <= 16000)
01911 s->coeff_per_sb_select = 1;
01912 else
01913 s->coeff_per_sb_select = 2;
01914
01915
01916 if ((s->fft_order < 7) || (s->fft_order > 9)) {
01917 av_log(avctx, AV_LOG_ERROR, "Unknown FFT order (%d), contact the developers!\n", s->fft_order);
01918 return -1;
01919 }
01920
01921 ff_fft_init(&s->fft_ctx, s->fft_order - 1, 1);
01922
01923 for (i = 1; i < (1 << (s->fft_order - 2)); i++) {
01924 alpha = 2 * M_PI * (float)i / (float)(1 << (s->fft_order - 1));
01925 s->exptab[i].re = cos(alpha);
01926 s->exptab[i].im = sin(alpha);
01927 }
01928
01929 qdm2_init(s);
01930
01931
01932 return 0;
01933 }
01934
01935
01936 static int qdm2_decode_close(AVCodecContext *avctx)
01937 {
01938 QDM2Context *s = avctx->priv_data;
01939
01940 ff_fft_end(&s->fft_ctx);
01941
01942 return 0;
01943 }
01944
01945
01946 static void qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
01947 {
01948 int ch, i;
01949 const int frame_size = (q->frame_size * q->channels);
01950
01951
01952 q->compressed_data = in;
01953 q->compressed_size = q->checksum_size;
01954
01955
01956
01957
01958 memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float));
01959 memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float));
01960
01961
01962 if (q->sub_packet == 0) {
01963 q->has_errors = 0;
01964 av_log(NULL,AV_LOG_DEBUG,"Superblock follows\n");
01965 qdm2_decode_super_block(q);
01966 }
01967
01968
01969 if (!q->has_errors) {
01970 if (q->sub_packet == 2)
01971 qdm2_decode_fft_packets(q);
01972
01973 qdm2_fft_tone_synthesizer(q, q->sub_packet);
01974 }
01975
01976
01977 for (ch = 0; ch < q->channels; ch++) {
01978 qdm2_calculate_fft(q, ch, q->sub_packet);
01979
01980 if (!q->has_errors && q->sub_packet_list_C[0].packet != NULL) {
01981 SAMPLES_NEEDED_2("has errors, and C list is not empty")
01982 return;
01983 }
01984 }
01985
01986
01987 if (!q->has_errors && q->do_synth_filter)
01988 qdm2_synthesis_filter(q, q->sub_packet);
01989
01990 q->sub_packet = (q->sub_packet + 1) % 16;
01991
01992
01993 for (i = 0; i < frame_size; i++) {
01994 int value = (int)q->output_buffer[i];
01995
01996 if (value > SOFTCLIP_THRESHOLD)
01997 value = (value > HARDCLIP_THRESHOLD) ? 32767 : softclip_table[ value - SOFTCLIP_THRESHOLD];
01998 else if (value < -SOFTCLIP_THRESHOLD)
01999 value = (value < -HARDCLIP_THRESHOLD) ? -32767 : -softclip_table[-value - SOFTCLIP_THRESHOLD];
02000
02001 out[i] = value;
02002 }
02003 }
02004
02005
02006 static int qdm2_decode_frame(AVCodecContext *avctx,
02007 void *data, int *data_size,
02008 const uint8_t *buf, int buf_size)
02009 {
02010 QDM2Context *s = avctx->priv_data;
02011
02012 if(!buf)
02013 return 0;
02014 if(buf_size < s->checksum_size)
02015 return -1;
02016
02017 *data_size = s->channels * s->frame_size * sizeof(int16_t);
02018
02019 av_log(avctx, AV_LOG_DEBUG, "decode(%d): %p[%d] -> %p[%d]\n",
02020 buf_size, buf, s->checksum_size, data, *data_size);
02021
02022 qdm2_decode(s, buf, data);
02023
02024
02025 if (s->sub_packet == 0) {
02026 return s->checksum_size;
02027 }
02028
02029 return 0;
02030 }
02031
02032 AVCodec qdm2_decoder =
02033 {
02034 .name = "qdm2",
02035 .type = CODEC_TYPE_AUDIO,
02036 .id = CODEC_ID_QDM2,
02037 .priv_data_size = sizeof(QDM2Context),
02038 .init = qdm2_decode_init,
02039 .close = qdm2_decode_close,
02040 .decode = qdm2_decode_frame,
02041 };