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