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