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