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