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