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 if (i >= FF_ARRAY_ELEMS(q->sub_packet_list_A)) {
01254 SAMPLES_NEEDED_2("too many packet bytes");
01255 return;
01256 }
01257
01258 q->sub_packet_list_A[i].next = NULL;
01259
01260 if (i > 0) {
01261 q->sub_packet_list_A[i - 1].next = &q->sub_packet_list_A[i];
01262
01263
01264 init_get_bits(&gb, header.data, header.size*8);
01265 skip_bits(&gb, next_index*8);
01266
01267 if (next_index >= header.size)
01268 break;
01269 }
01270
01271
01272 packet = &q->sub_packets[i];
01273 qdm2_decode_sub_packet_header(&gb, packet);
01274 next_index = packet->size + get_bits_count(&gb) / 8;
01275 sub_packet_size = ((packet->size > 0xff) ? 1 : 0) + packet->size + 2;
01276
01277 if (packet->type == 0)
01278 break;
01279
01280 if (sub_packet_size > packet_bytes) {
01281 if (packet->type != 10 && packet->type != 11 && packet->type != 12)
01282 break;
01283 packet->size += packet_bytes - sub_packet_size;
01284 }
01285
01286 packet_bytes -= sub_packet_size;
01287
01288
01289 q->sub_packet_list_A[i].packet = packet;
01290
01291
01292 if (packet->type == 8) {
01293 SAMPLES_NEEDED_2("packet type 8");
01294 return;
01295 } else if (packet->type >= 9 && packet->type <= 12) {
01296
01297 QDM2_LIST_ADD(q->sub_packet_list_D, sub_packets_D, packet);
01298 } else if (packet->type == 13) {
01299 for (j = 0; j < 6; j++)
01300 q->fft_level_exp[j] = get_bits(&gb, 6);
01301 } else if (packet->type == 14) {
01302 for (j = 0; j < 6; j++)
01303 q->fft_level_exp[j] = qdm2_get_vlc(&gb, &fft_level_exp_vlc, 0, 2);
01304 } else if (packet->type == 15) {
01305 SAMPLES_NEEDED_2("packet type 15")
01306 return;
01307 } else if (packet->type >= 16 && packet->type < 48 && !fft_subpackets[packet->type - 16]) {
01308
01309 QDM2_LIST_ADD(q->sub_packet_list_B, q->sub_packets_B, packet);
01310 }
01311 }
01312
01313
01314 if (q->sub_packet_list_D[0].packet != NULL) {
01315 process_synthesis_subpackets(q, q->sub_packet_list_D);
01316 q->do_synth_filter = 1;
01317 } else if (q->do_synth_filter) {
01318 process_subpacket_10(q, NULL, 0);
01319 process_subpacket_11(q, NULL, 0);
01320 process_subpacket_12(q, NULL, 0);
01321 }
01322
01323 }
01324
01325
01326 static void qdm2_fft_init_coefficient (QDM2Context *q, int sub_packet,
01327 int offset, int duration, int channel,
01328 int exp, int phase)
01329 {
01330 if (q->fft_coefs_min_index[duration] < 0)
01331 q->fft_coefs_min_index[duration] = q->fft_coefs_index;
01332
01333 q->fft_coefs[q->fft_coefs_index].sub_packet = ((sub_packet >= 16) ? (sub_packet - 16) : sub_packet);
01334 q->fft_coefs[q->fft_coefs_index].channel = channel;
01335 q->fft_coefs[q->fft_coefs_index].offset = offset;
01336 q->fft_coefs[q->fft_coefs_index].exp = exp;
01337 q->fft_coefs[q->fft_coefs_index].phase = phase;
01338 q->fft_coefs_index++;
01339 }
01340
01341
01342 static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *gb, int b)
01343 {
01344 int channel, stereo, phase, exp;
01345 int local_int_4, local_int_8, stereo_phase, local_int_10;
01346 int local_int_14, stereo_exp, local_int_20, local_int_28;
01347 int n, offset;
01348
01349 local_int_4 = 0;
01350 local_int_28 = 0;
01351 local_int_20 = 2;
01352 local_int_8 = (4 - duration);
01353 local_int_10 = 1 << (q->group_order - duration - 1);
01354 offset = 1;
01355
01356 while (1) {
01357 if (q->superblocktype_2_3) {
01358 while ((n = qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2)) < 2) {
01359 offset = 1;
01360 if (n == 0) {
01361 local_int_4 += local_int_10;
01362 local_int_28 += (1 << local_int_8);
01363 } else {
01364 local_int_4 += 8*local_int_10;
01365 local_int_28 += (8 << local_int_8);
01366 }
01367 }
01368 offset += (n - 2);
01369 } else {
01370 offset += qdm2_get_vlc(gb, &vlc_tab_fft_tone_offset[local_int_8], 1, 2);
01371 while (offset >= (local_int_10 - 1)) {
01372 offset += (1 - (local_int_10 - 1));
01373 local_int_4 += local_int_10;
01374 local_int_28 += (1 << local_int_8);
01375 }
01376 }
01377
01378 if (local_int_4 >= q->group_size)
01379 return;
01380
01381 local_int_14 = (offset >> local_int_8);
01382 if (local_int_14 >= FF_ARRAY_ELEMS(fft_level_index_table))
01383 return;
01384
01385 if (q->nb_channels > 1) {
01386 channel = get_bits1(gb);
01387 stereo = get_bits1(gb);
01388 } else {
01389 channel = 0;
01390 stereo = 0;
01391 }
01392
01393 exp = qdm2_get_vlc(gb, (b ? &fft_level_exp_vlc : &fft_level_exp_alt_vlc), 0, 2);
01394 exp += q->fft_level_exp[fft_level_index_table[local_int_14]];
01395 exp = (exp < 0) ? 0 : exp;
01396
01397 phase = get_bits(gb, 3);
01398 stereo_exp = 0;
01399 stereo_phase = 0;
01400
01401 if (stereo) {
01402 stereo_exp = (exp - qdm2_get_vlc(gb, &fft_stereo_exp_vlc, 0, 1));
01403 stereo_phase = (phase - qdm2_get_vlc(gb, &fft_stereo_phase_vlc, 0, 1));
01404 if (stereo_phase < 0)
01405 stereo_phase += 8;
01406 }
01407
01408 if (q->frequency_range > (local_int_14 + 1)) {
01409 int sub_packet = (local_int_20 + local_int_28);
01410
01411 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, channel, exp, phase);
01412 if (stereo)
01413 qdm2_fft_init_coefficient(q, sub_packet, offset, duration, (1 - channel), stereo_exp, stereo_phase);
01414 }
01415
01416 offset++;
01417 }
01418 }
01419
01420
01421 static void qdm2_decode_fft_packets (QDM2Context *q)
01422 {
01423 int i, j, min, max, value, type, unknown_flag;
01424 GetBitContext gb;
01425
01426 if (q->sub_packet_list_B[0].packet == NULL)
01427 return;
01428
01429
01430 q->fft_coefs_index = 0;
01431 for (i=0; i < 5; i++)
01432 q->fft_coefs_min_index[i] = -1;
01433
01434
01435 for (i = 0, max = 256; i < q->sub_packets_B; i++) {
01436 QDM2SubPacket *packet= NULL;
01437
01438
01439 for (j = 0, min = 0; j < q->sub_packets_B; j++) {
01440 value = q->sub_packet_list_B[j].packet->type;
01441 if (value > min && value < max) {
01442 min = value;
01443 packet = q->sub_packet_list_B[j].packet;
01444 }
01445 }
01446
01447 max = min;
01448
01449
01450 if (!packet)
01451 return;
01452
01453 if (i == 0 && (packet->type < 16 || packet->type >= 48 || fft_subpackets[packet->type - 16]))
01454 return;
01455
01456
01457 init_get_bits (&gb, packet->data, packet->size*8);
01458
01459 if (packet->type >= 32 && packet->type < 48 && !fft_subpackets[packet->type - 16])
01460 unknown_flag = 1;
01461 else
01462 unknown_flag = 0;
01463
01464 type = packet->type;
01465
01466 if ((type >= 17 && type < 24) || (type >= 33 && type < 40)) {
01467 int duration = q->sub_sampling + 5 - (type & 15);
01468
01469 if (duration >= 0 && duration < 4)
01470 qdm2_fft_decode_tones(q, duration, &gb, unknown_flag);
01471 } else if (type == 31) {
01472 for (j=0; j < 4; j++)
01473 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
01474 } else if (type == 46) {
01475 for (j=0; j < 6; j++)
01476 q->fft_level_exp[j] = get_bits(&gb, 6);
01477 for (j=0; j < 4; j++)
01478 qdm2_fft_decode_tones(q, j, &gb, unknown_flag);
01479 }
01480 }
01481
01482
01483 for (i = 0, j = -1; i < 5; i++)
01484 if (q->fft_coefs_min_index[i] >= 0) {
01485 if (j >= 0)
01486 q->fft_coefs_max_index[j] = q->fft_coefs_min_index[i];
01487 j = i;
01488 }
01489 if (j >= 0)
01490 q->fft_coefs_max_index[j] = q->fft_coefs_index;
01491 }
01492
01493
01494 static void qdm2_fft_generate_tone (QDM2Context *q, FFTTone *tone)
01495 {
01496 float level, f[6];
01497 int i;
01498 QDM2Complex c;
01499 const double iscale = 2.0*M_PI / 512.0;
01500
01501 tone->phase += tone->phase_shift;
01502
01503
01504 level = fft_tone_envelope_table[tone->duration][tone->time_index] * tone->level;
01505 c.im = level * sin(tone->phase*iscale);
01506 c.re = level * cos(tone->phase*iscale);
01507
01508
01509 if (tone->duration >= 3 || tone->cutoff >= 3) {
01510 tone->complex[0].im += c.im;
01511 tone->complex[0].re += c.re;
01512 tone->complex[1].im -= c.im;
01513 tone->complex[1].re -= c.re;
01514 } else {
01515 f[1] = -tone->table[4];
01516 f[0] = tone->table[3] - tone->table[0];
01517 f[2] = 1.0 - tone->table[2] - tone->table[3];
01518 f[3] = tone->table[1] + tone->table[4] - 1.0;
01519 f[4] = tone->table[0] - tone->table[1];
01520 f[5] = tone->table[2];
01521 for (i = 0; i < 2; i++) {
01522 tone->complex[fft_cutoff_index_table[tone->cutoff][i]].re += c.re * f[i];
01523 tone->complex[fft_cutoff_index_table[tone->cutoff][i]].im += c.im *((tone->cutoff <= i) ? -f[i] : f[i]);
01524 }
01525 for (i = 0; i < 4; i++) {
01526 tone->complex[i].re += c.re * f[i+2];
01527 tone->complex[i].im += c.im * f[i+2];
01528 }
01529 }
01530
01531
01532 if (++tone->time_index < ((1 << (5 - tone->duration)) - 1)) {
01533 memcpy(&q->fft_tones[q->fft_tone_end], tone, sizeof(FFTTone));
01534 q->fft_tone_end = (q->fft_tone_end + 1) % 1000;
01535 }
01536 }
01537
01538
01539 static void qdm2_fft_tone_synthesizer (QDM2Context *q, int sub_packet)
01540 {
01541 int i, j, ch;
01542 const double iscale = 0.25 * M_PI;
01543
01544 for (ch = 0; ch < q->channels; ch++) {
01545 memset(q->fft.complex[ch], 0, q->fft_size * sizeof(QDM2Complex));
01546 }
01547
01548
01549
01550 if (q->fft_coefs_min_index[4] >= 0)
01551 for (i = q->fft_coefs_min_index[4]; i < q->fft_coefs_max_index[4]; i++) {
01552 float level;
01553 QDM2Complex c;
01554
01555 if (q->fft_coefs[i].sub_packet != sub_packet)
01556 break;
01557
01558 ch = (q->channels == 1) ? 0 : q->fft_coefs[i].channel;
01559 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];
01560
01561 c.re = level * cos(q->fft_coefs[i].phase * iscale);
01562 c.im = level * sin(q->fft_coefs[i].phase * iscale);
01563 q->fft.complex[ch][q->fft_coefs[i].offset + 0].re += c.re;
01564 q->fft.complex[ch][q->fft_coefs[i].offset + 0].im += c.im;
01565 q->fft.complex[ch][q->fft_coefs[i].offset + 1].re -= c.re;
01566 q->fft.complex[ch][q->fft_coefs[i].offset + 1].im -= c.im;
01567 }
01568
01569
01570 for (i = q->fft_tone_end; i != q->fft_tone_start; ) {
01571 qdm2_fft_generate_tone(q, &q->fft_tones[q->fft_tone_start]);
01572 q->fft_tone_start = (q->fft_tone_start + 1) % 1000;
01573 }
01574
01575
01576 for (i = 0; i < 4; i++)
01577 if (q->fft_coefs_min_index[i] >= 0) {
01578 for (j = q->fft_coefs_min_index[i]; j < q->fft_coefs_max_index[i]; j++) {
01579 int offset, four_i;
01580 FFTTone tone;
01581
01582 if (q->fft_coefs[j].sub_packet != sub_packet)
01583 break;
01584
01585 four_i = (4 - i);
01586 offset = q->fft_coefs[j].offset >> four_i;
01587 ch = (q->channels == 1) ? 0 : q->fft_coefs[j].channel;
01588
01589 if (offset < q->frequency_range) {
01590 if (offset < 2)
01591 tone.cutoff = offset;
01592 else
01593 tone.cutoff = (offset >= 60) ? 3 : 2;
01594
01595 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];
01596 tone.complex = &q->fft.complex[ch][offset];
01597 tone.table = fft_tone_sample_table[i][q->fft_coefs[j].offset - (offset << four_i)];
01598 tone.phase = 64 * q->fft_coefs[j].phase - (offset << 8) - 128;
01599 tone.phase_shift = (2 * q->fft_coefs[j].offset + 1) << (7 - four_i);
01600 tone.duration = i;
01601 tone.time_index = 0;
01602
01603 qdm2_fft_generate_tone(q, &tone);
01604 }
01605 }
01606 q->fft_coefs_min_index[i] = j;
01607 }
01608 }
01609
01610
01611 static void qdm2_calculate_fft (QDM2Context *q, int channel, int sub_packet)
01612 {
01613 const float gain = (q->channels == 1 && q->nb_channels == 2) ? 0.5f : 1.0f;
01614 int i;
01615 q->fft.complex[channel][0].re *= 2.0f;
01616 q->fft.complex[channel][0].im = 0.0f;
01617 q->rdft_ctx.rdft_calc(&q->rdft_ctx, (FFTSample *)q->fft.complex[channel]);
01618
01619 for (i = 0; i < ((q->fft_frame_size + 15) & ~15); i++)
01620 q->output_buffer[q->channels * i + channel] += ((float *) q->fft.complex[channel])[i] * gain;
01621 }
01622
01623
01628 static void qdm2_synthesis_filter (QDM2Context *q, int index)
01629 {
01630 int i, k, ch, sb_used, sub_sampling, dither_state = 0;
01631
01632
01633 sb_used = QDM2_SB_USED(q->sub_sampling);
01634
01635 for (ch = 0; ch < q->channels; ch++)
01636 for (i = 0; i < 8; i++)
01637 for (k=sb_used; k < SBLIMIT; k++)
01638 q->sb_samples[ch][(8 * index) + i][k] = 0;
01639
01640 for (ch = 0; ch < q->nb_channels; ch++) {
01641 float *samples_ptr = q->samples + ch;
01642
01643 for (i = 0; i < 8; i++) {
01644 ff_mpa_synth_filter_float(&q->mpadsp,
01645 q->synth_buf[ch], &(q->synth_buf_offset[ch]),
01646 ff_mpa_synth_window_float, &dither_state,
01647 samples_ptr, q->nb_channels,
01648 q->sb_samples[ch][(8 * index) + i]);
01649 samples_ptr += 32 * q->nb_channels;
01650 }
01651 }
01652
01653
01654 sub_sampling = (4 >> q->sub_sampling);
01655
01656 for (ch = 0; ch < q->channels; ch++)
01657 for (i = 0; i < q->frame_size; i++)
01658 q->output_buffer[q->channels * i + ch] += (1 << 23) * q->samples[q->nb_channels * sub_sampling * i + ch];
01659 }
01660
01661
01667 static av_cold void qdm2_init(QDM2Context *q) {
01668 static int initialized = 0;
01669
01670 if (initialized != 0)
01671 return;
01672 initialized = 1;
01673
01674 qdm2_init_vlc();
01675 ff_mpa_synth_init_float(ff_mpa_synth_window_float);
01676 softclip_table_init();
01677 rnd_table_init();
01678 init_noise_samples();
01679
01680 av_log(NULL, AV_LOG_DEBUG, "init done\n");
01681 }
01682
01683
01684 #if 0
01685 static void dump_context(QDM2Context *q)
01686 {
01687 int i;
01688 #define PRINT(a,b) av_log(NULL,AV_LOG_DEBUG," %s = %d\n", a, b);
01689 PRINT("compressed_data",q->compressed_data);
01690 PRINT("compressed_size",q->compressed_size);
01691 PRINT("frame_size",q->frame_size);
01692 PRINT("checksum_size",q->checksum_size);
01693 PRINT("channels",q->channels);
01694 PRINT("nb_channels",q->nb_channels);
01695 PRINT("fft_frame_size",q->fft_frame_size);
01696 PRINT("fft_size",q->fft_size);
01697 PRINT("sub_sampling",q->sub_sampling);
01698 PRINT("fft_order",q->fft_order);
01699 PRINT("group_order",q->group_order);
01700 PRINT("group_size",q->group_size);
01701 PRINT("sub_packet",q->sub_packet);
01702 PRINT("frequency_range",q->frequency_range);
01703 PRINT("has_errors",q->has_errors);
01704 PRINT("fft_tone_end",q->fft_tone_end);
01705 PRINT("fft_tone_start",q->fft_tone_start);
01706 PRINT("fft_coefs_index",q->fft_coefs_index);
01707 PRINT("coeff_per_sb_select",q->coeff_per_sb_select);
01708 PRINT("cm_table_select",q->cm_table_select);
01709 PRINT("noise_idx",q->noise_idx);
01710
01711 for (i = q->fft_tone_start; i < q->fft_tone_end; i++)
01712 {
01713 FFTTone *t = &q->fft_tones[i];
01714
01715 av_log(NULL,AV_LOG_DEBUG,"Tone (%d) dump:\n", i);
01716 av_log(NULL,AV_LOG_DEBUG," level = %f\n", t->level);
01717
01718 PRINT(" phase", t->phase);
01719 PRINT(" phase_shift", t->phase_shift);
01720 PRINT(" duration", t->duration);
01721 PRINT(" samples_im", t->samples_im);
01722 PRINT(" samples_re", t->samples_re);
01723 PRINT(" table", t->table);
01724 }
01725
01726 }
01727 #endif
01728
01729
01733 static av_cold int qdm2_decode_init(AVCodecContext *avctx)
01734 {
01735 QDM2Context *s = avctx->priv_data;
01736 uint8_t *extradata;
01737 int extradata_size;
01738 int tmp_val, tmp, size;
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772
01773
01774 if (!avctx->extradata || (avctx->extradata_size < 48)) {
01775 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
01776 return -1;
01777 }
01778
01779 extradata = avctx->extradata;
01780 extradata_size = avctx->extradata_size;
01781
01782 while (extradata_size > 7) {
01783 if (!memcmp(extradata, "frmaQDM", 7))
01784 break;
01785 extradata++;
01786 extradata_size--;
01787 }
01788
01789 if (extradata_size < 12) {
01790 av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
01791 extradata_size);
01792 return -1;
01793 }
01794
01795 if (memcmp(extradata, "frmaQDM", 7)) {
01796 av_log(avctx, AV_LOG_ERROR, "invalid headers, QDM? not found\n");
01797 return -1;
01798 }
01799
01800 if (extradata[7] == 'C') {
01801
01802 av_log(avctx, AV_LOG_ERROR, "stream is QDMC version 1, which is not supported\n");
01803 return -1;
01804 }
01805
01806 extradata += 8;
01807 extradata_size -= 8;
01808
01809 size = AV_RB32(extradata);
01810
01811 if(size > extradata_size){
01812 av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
01813 extradata_size, size);
01814 return -1;
01815 }
01816
01817 extradata += 4;
01818 av_log(avctx, AV_LOG_DEBUG, "size: %d\n", size);
01819 if (AV_RB32(extradata) != MKBETAG('Q','D','C','A')) {
01820 av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
01821 return -1;
01822 }
01823
01824 extradata += 8;
01825
01826 avctx->channels = s->nb_channels = s->channels = AV_RB32(extradata);
01827 extradata += 4;
01828 if (s->channels > MPA_MAX_CHANNELS)
01829 return AVERROR_INVALIDDATA;
01830
01831 avctx->sample_rate = AV_RB32(extradata);
01832 extradata += 4;
01833
01834 avctx->bit_rate = AV_RB32(extradata);
01835 extradata += 4;
01836
01837 s->group_size = AV_RB32(extradata);
01838 extradata += 4;
01839
01840 s->fft_size = AV_RB32(extradata);
01841 extradata += 4;
01842
01843 s->checksum_size = AV_RB32(extradata);
01844 if (s->checksum_size >= 1U << 28) {
01845 av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
01846 return AVERROR_INVALIDDATA;
01847 }
01848
01849 s->fft_order = av_log2(s->fft_size) + 1;
01850 s->fft_frame_size = 2 * s->fft_size;
01851
01852
01853 s->group_order = av_log2(s->group_size) + 1;
01854 s->frame_size = s->group_size / 16;
01855 if (s->frame_size > QDM2_MAX_FRAME_SIZE)
01856 return AVERROR_INVALIDDATA;
01857
01858 s->sub_sampling = s->fft_order - 7;
01859 s->frequency_range = 255 / (1 << (2 - s->sub_sampling));
01860
01861 switch ((s->sub_sampling * 2 + s->channels - 1)) {
01862 case 0: tmp = 40; break;
01863 case 1: tmp = 48; break;
01864 case 2: tmp = 56; break;
01865 case 3: tmp = 72; break;
01866 case 4: tmp = 80; break;
01867 case 5: tmp = 100;break;
01868 default: tmp=s->sub_sampling; break;
01869 }
01870 tmp_val = 0;
01871 if ((tmp * 1000) < avctx->bit_rate) tmp_val = 1;
01872 if ((tmp * 1440) < avctx->bit_rate) tmp_val = 2;
01873 if ((tmp * 1760) < avctx->bit_rate) tmp_val = 3;
01874 if ((tmp * 2240) < avctx->bit_rate) tmp_val = 4;
01875 s->cm_table_select = tmp_val;
01876
01877 if (s->sub_sampling == 0)
01878 tmp = 7999;
01879 else
01880 tmp = ((-(s->sub_sampling -1)) & 8000) + 20000;
01881
01882
01883
01884
01885
01886 if (tmp < 8000)
01887 s->coeff_per_sb_select = 0;
01888 else if (tmp <= 16000)
01889 s->coeff_per_sb_select = 1;
01890 else
01891 s->coeff_per_sb_select = 2;
01892
01893
01894 if ((s->fft_order < 7) || (s->fft_order > 9)) {
01895 av_log(avctx, AV_LOG_ERROR, "Unknown FFT order (%d), contact the developers!\n", s->fft_order);
01896 return -1;
01897 }
01898 if (s->fft_size != (1 << (s->fft_order - 1))) {
01899 av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", s->fft_size);
01900 return AVERROR_INVALIDDATA;
01901 }
01902
01903 ff_rdft_init(&s->rdft_ctx, s->fft_order, IDFT_C2R);
01904 ff_mpadsp_init(&s->mpadsp);
01905
01906 qdm2_init(s);
01907
01908 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
01909
01910 avcodec_get_frame_defaults(&s->frame);
01911 avctx->coded_frame = &s->frame;
01912
01913
01914 return 0;
01915 }
01916
01917
01918 static av_cold int qdm2_decode_close(AVCodecContext *avctx)
01919 {
01920 QDM2Context *s = avctx->priv_data;
01921
01922 ff_rdft_end(&s->rdft_ctx);
01923
01924 return 0;
01925 }
01926
01927
01928 static int qdm2_decode (QDM2Context *q, const uint8_t *in, int16_t *out)
01929 {
01930 int ch, i;
01931 const int frame_size = (q->frame_size * q->channels);
01932
01933
01934 q->compressed_data = in;
01935 q->compressed_size = q->checksum_size;
01936
01937
01938
01939
01940 memmove(q->output_buffer, &q->output_buffer[frame_size], frame_size * sizeof(float));
01941 memset(&q->output_buffer[frame_size], 0, frame_size * sizeof(float));
01942
01943
01944 if (q->sub_packet == 0) {
01945 q->has_errors = 0;
01946 av_log(NULL,AV_LOG_DEBUG,"Superblock follows\n");
01947 qdm2_decode_super_block(q);
01948 }
01949
01950
01951 if (!q->has_errors) {
01952 if (q->sub_packet == 2)
01953 qdm2_decode_fft_packets(q);
01954
01955 qdm2_fft_tone_synthesizer(q, q->sub_packet);
01956 }
01957
01958
01959 for (ch = 0; ch < q->channels; ch++) {
01960 qdm2_calculate_fft(q, ch, q->sub_packet);
01961
01962 if (!q->has_errors && q->sub_packet_list_C[0].packet != NULL) {
01963 SAMPLES_NEEDED_2("has errors, and C list is not empty")
01964 return -1;
01965 }
01966 }
01967
01968
01969 if (!q->has_errors && q->do_synth_filter)
01970 qdm2_synthesis_filter(q, q->sub_packet);
01971
01972 q->sub_packet = (q->sub_packet + 1) % 16;
01973
01974
01975 for (i = 0; i < frame_size; i++) {
01976 int value = (int)q->output_buffer[i];
01977
01978 if (value > SOFTCLIP_THRESHOLD)
01979 value = (value > HARDCLIP_THRESHOLD) ? 32767 : softclip_table[ value - SOFTCLIP_THRESHOLD];
01980 else if (value < -SOFTCLIP_THRESHOLD)
01981 value = (value < -HARDCLIP_THRESHOLD) ? -32767 : -softclip_table[-value - SOFTCLIP_THRESHOLD];
01982
01983 out[i] = value;
01984 }
01985
01986 return 0;
01987 }
01988
01989
01990 static int qdm2_decode_frame(AVCodecContext *avctx, void *data,
01991 int *got_frame_ptr, AVPacket *avpkt)
01992 {
01993 const uint8_t *buf = avpkt->data;
01994 int buf_size = avpkt->size;
01995 QDM2Context *s = avctx->priv_data;
01996 int16_t *out;
01997 int i, ret;
01998
01999 if(!buf)
02000 return 0;
02001 if(buf_size < s->checksum_size)
02002 return -1;
02003
02004
02005 s->frame.nb_samples = 16 * s->frame_size;
02006 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
02007 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
02008 return ret;
02009 }
02010 out = (int16_t *)s->frame.data[0];
02011
02012 for (i = 0; i < 16; i++) {
02013 if (qdm2_decode(s, buf, out) < 0)
02014 return -1;
02015 out += s->channels * s->frame_size;
02016 }
02017
02018 *got_frame_ptr = 1;
02019 *(AVFrame *)data = s->frame;
02020
02021 return s->checksum_size;
02022 }
02023
02024 AVCodec ff_qdm2_decoder =
02025 {
02026 .name = "qdm2",
02027 .type = AVMEDIA_TYPE_AUDIO,
02028 .id = CODEC_ID_QDM2,
02029 .priv_data_size = sizeof(QDM2Context),
02030 .init = qdm2_decode_init,
02031 .close = qdm2_decode_close,
02032 .decode = qdm2_decode_frame,
02033 .capabilities = CODEC_CAP_DR1,
02034 .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 2"),
02035 };