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