49 #define MAX_LSPS_ALIGN16 16
52 #define MAX_FRAMESIZE 160
53 #define MAX_SIGNAL_HISTORY 416
54 #define MAX_SFRAMESIZE (MAX_FRAMESIZE * MAX_FRAMES)
56 #define SFRAME_CACHE_MAXSIZE 256
302 int cntr[8] = { 0 }, n, res;
304 memset(vbm_tree, 0xff,
sizeof(vbm_tree[0]) * 25);
305 for (n = 0; n < 17; n++) {
309 vbm_tree[res * 3 + cntr[res]++] = n;
319 10, 10, 10, 12, 12, 12,
322 static const uint16_t codes[] = {
323 0x0000, 0x0001, 0x0002,
324 0x000c, 0x000d, 0x000e,
325 0x003c, 0x003d, 0x003e,
326 0x00fc, 0x00fd, 0x00fe,
327 0x03fc, 0x03fd, 0x03fe,
328 0x0ffc, 0x0ffd, 0x0ffe,
329 0x3ffc, 0x3ffd, 0x3ffe, 0x3fff
333 bits, 1, 1, codes, 2, 2, 132);
341 s->postfilter_agc = 0;
342 s->sframe_cache_size = 0;
343 s->skip_bits_next = 0;
344 for (n = 0; n <
s->lsps; n++)
345 s->prev_lsps[n] =
M_PI * (n + 1.0) / (
s->lsps + 1.0);
346 memset(
s->excitation_history, 0,
348 memset(
s->synth_history, 0,
350 memset(
s->gain_pred_err, 0,
351 sizeof(
s->gain_pred_err));
355 sizeof(*
s->synth_filter_out_buf) *
s->lsps);
356 memset(
s->dcf_mem, 0,
357 sizeof(*
s->dcf_mem) * 2);
358 memset(
s->zero_exc_pf, 0,
359 sizeof(*
s->zero_exc_pf) *
s->history_nsamples);
360 memset(
s->denoise_filter_cache, 0,
sizeof(
s->denoise_filter_cache));
370 int n,
flags, pitch_range, lsp16_flag, ret;
383 if (
ctx->extradata_size != 46) {
385 "Invalid extradata size %d (should be 46)\n",
386 ctx->extradata_size);
389 if (
ctx->block_align <= 0 ||
ctx->block_align > (1<<22)) {
405 memcpy(&
s->sin[255],
s->cos, 256 *
sizeof(
s->cos[0]));
406 for (n = 0; n < 255; n++) {
407 s->sin[n] = -
s->sin[510 - n];
408 s->cos[510 - n] =
s->cos[n];
411 s->denoise_strength = (
flags >> 2) & 0xF;
412 if (
s->denoise_strength >= 12) {
414 "Invalid denoise filter strength %d (max=11)\n",
415 s->denoise_strength);
418 s->denoise_tilt_corr = !!(
flags & 0x40);
419 s->dc_level = (
flags >> 7) & 0xF;
420 s->lsp_q_mode = !!(
flags & 0x2000);
421 s->lsp_def_mode = !!(
flags & 0x4000);
422 lsp16_flag =
flags & 0x1000;
428 for (n = 0; n <
s->lsps; n++)
429 s->prev_lsps[n] =
M_PI * (n + 1.0) / (
s->lsps + 1.0);
437 if (
ctx->sample_rate >= INT_MAX / (256 * 37))
440 s->min_pitch_val = ((
ctx->sample_rate << 8) / 400 + 50) >> 8;
441 s->max_pitch_val = ((
ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
442 pitch_range =
s->max_pitch_val -
s->min_pitch_val;
443 if (pitch_range <= 0) {
448 s->last_pitch_val = 40;
450 s->history_nsamples =
s->max_pitch_val + 8;
453 int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
457 "Unsupported samplerate %d (min=%d, max=%d)\n",
458 ctx->sample_rate, min_sr, max_sr);
463 s->block_conv_table[0] =
s->min_pitch_val;
464 s->block_conv_table[1] = (pitch_range * 25) >> 6;
465 s->block_conv_table[2] = (pitch_range * 44) >> 6;
466 s->block_conv_table[3] =
s->max_pitch_val - 1;
467 s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
468 if (
s->block_delta_pitch_hrange <= 0) {
472 s->block_delta_pitch_nbits = 1 +
av_ceil_log2(
s->block_delta_pitch_hrange);
473 s->block_pitch_range =
s->block_conv_table[2] +
474 s->block_conv_table[3] + 1 +
475 2 * (
s->block_conv_table[1] - 2 *
s->min_pitch_val);
507 const float *speech_synth,
511 float speech_energy = 0.0, postfilter_energy = 0.0, gain_scale_factor;
512 float mem = *gain_mem;
515 speech_energy +=
fabsf(speech_synth[
i]);
518 gain_scale_factor = postfilter_energy == 0.0 ? 0.0 :
519 (1.0 -
alpha) * speech_energy / postfilter_energy;
522 mem =
alpha * mem + gain_scale_factor;
551 float optimal_gain = 0, dot;
552 const float *ptr = &
in[-
FFMAX(
s->min_pitch_val, pitch - 3)],
553 *end = &
in[-
FFMIN(
s->max_pitch_val, pitch + 3)],
554 *best_hist_ptr =
NULL;
559 if (dot > optimal_gain) {
563 }
while (--ptr >= end);
565 if (optimal_gain <= 0)
571 if (optimal_gain <= dot) {
572 dot = dot / (dot + 0.6 * optimal_gain);
577 for (n = 0; n <
size; n++)
578 out[n] = best_hist_ptr[n] + dot * (
in[n] - best_hist_ptr[n]);
607 int fcb_type,
float *coeffs,
int remainder)
610 float irange, angle_mul, gain_mul, range, sq;
614 s->rdft.rdft_calc(&
s->rdft, lpcs);
615 #define log_range(var, assign) do { \
616 float tmp = log10f(assign); var = tmp; \
617 max = FFMAX(max, tmp); min = FFMIN(min, tmp); \
620 for (n = 1; n < 64; n++)
621 log_range(lpcs[n], lpcs[n * 2] * lpcs[n * 2] +
622 lpcs[n * 2 + 1] * lpcs[n * 2 + 1]);
633 irange = 64.0 / range;
637 for (n = 0; n <= 64; n++) {
640 idx =
lrint((
max - lpcs[n]) * irange - 1);
643 lpcs[n] = angle_mul * pwr;
646 idx =
av_clipf((pwr * gain_mul - 0.0295) * 70.570526123, 0, INT_MAX / 2);
650 powf(1.0331663, idx - 127);
659 s->dct.dct_calc(&
s->dct, lpcs);
660 s->dst.dct_calc(&
s->dst, lpcs);
663 idx = 255 +
av_clip(lpcs[64], -255, 255);
664 coeffs[0] = coeffs[0] *
s->cos[idx];
665 idx = 255 +
av_clip(lpcs[64] - 2 * lpcs[63], -255, 255);
668 idx = 255 +
av_clip(-lpcs[64] - 2 * lpcs[n - 1], -255, 255);
669 coeffs[n * 2 + 1] = coeffs[n] *
s->sin[idx];
670 coeffs[n * 2] = coeffs[n] *
s->cos[idx];
674 idx = 255 +
av_clip( lpcs[64] - 2 * lpcs[n - 1], -255, 255);
675 coeffs[n * 2 + 1] = coeffs[n] *
s->sin[idx];
676 coeffs[n * 2] = coeffs[n] *
s->cos[idx];
681 s->irdft.rdft_calc(&
s->irdft, coeffs);
684 memset(&coeffs[remainder], 0,
sizeof(coeffs[0]) * (128 - remainder));
685 if (
s->denoise_tilt_corr) {
688 coeffs[remainder - 1] = 0;
695 for (n = 0; n < remainder; n++)
726 float *synth_pf,
int size,
729 int remainder, lim, n;
732 float *tilted_lpcs =
s->tilted_lpcs_pf,
733 *coeffs =
s->denoise_coeffs_pf, tilt_mem = 0;
735 tilted_lpcs[0] = 1.0;
736 memcpy(&tilted_lpcs[1], lpcs,
sizeof(lpcs[0]) *
s->lsps);
737 memset(&tilted_lpcs[
s->lsps + 1], 0,
738 sizeof(tilted_lpcs[0]) * (128 -
s->lsps - 1));
740 tilted_lpcs,
s->lsps + 2);
751 memset(&synth_pf[
size], 0,
sizeof(synth_pf[0]) * (128 -
size));
752 s->rdft.rdft_calc(&
s->rdft, synth_pf);
753 s->rdft.rdft_calc(&
s->rdft, coeffs);
754 synth_pf[0] *= coeffs[0];
755 synth_pf[1] *= coeffs[1];
756 for (n = 1; n < 64; n++) {
757 float v1 = synth_pf[n * 2], v2 = synth_pf[n * 2 + 1];
758 synth_pf[n * 2] = v1 * coeffs[n * 2] - v2 * coeffs[n * 2 + 1];
759 synth_pf[n * 2 + 1] = v2 * coeffs[n * 2] + v1 * coeffs[n * 2 + 1];
761 s->irdft.rdft_calc(&
s->irdft, synth_pf);
765 if (
s->denoise_filter_cache_size) {
766 lim =
FFMIN(
s->denoise_filter_cache_size,
size);
767 for (n = 0; n < lim; n++)
768 synth_pf[n] +=
s->denoise_filter_cache[n];
769 s->denoise_filter_cache_size -= lim;
770 memmove(
s->denoise_filter_cache, &
s->denoise_filter_cache[
size],
771 sizeof(
s->denoise_filter_cache[0]) *
s->denoise_filter_cache_size);
776 lim =
FFMIN(remainder,
s->denoise_filter_cache_size);
777 for (n = 0; n < lim; n++)
778 s->denoise_filter_cache[n] += synth_pf[
size + n];
779 if (lim < remainder) {
780 memcpy(&
s->denoise_filter_cache[lim], &synth_pf[
size + lim],
781 sizeof(
s->denoise_filter_cache[0]) * (remainder - lim));
782 s->denoise_filter_cache_size = remainder;
808 float *samples,
int size,
809 const float *lpcs,
float *zero_exc_pf,
810 int fcb_type,
int pitch)
814 *synth_filter_in = zero_exc_pf;
823 synth_filter_in = synth_filter_in_buf;
827 synth_filter_in,
size,
s->lsps);
828 memcpy(&synth_pf[-
s->lsps], &synth_pf[
size -
s->lsps],
829 sizeof(synth_pf[0]) *
s->lsps);
836 if (
s->dc_level > 8) {
841 (
const float[2]) { -1.99997, 1.0 },
842 (
const float[2]) { -1.9330735188, 0.93589198496 },
843 0.93980580475,
s->dcf_mem,
size);
862 const uint16_t *values,
863 const uint16_t *
sizes,
866 const double *base_q)
870 memset(lsps, 0, num *
sizeof(*lsps));
871 for (n = 0; n < n_stages; n++) {
873 double base = base_q[n],
mul = mul_q[n];
875 for (m = 0; m < num; m++)
876 lsps[m] +=
base +
mul * t_off[m];
894 static const uint16_t vec_sizes[4] = { 256, 64, 32, 32 };
895 static const double mul_lsf[4] = {
896 5.2187144800e-3, 1.4626986422e-3,
897 9.6179549166e-4, 1.1325736225e-3
899 static const double base_lsf[4] = {
900 M_PI * -2.15522e-1,
M_PI * -6.1646e-2,
901 M_PI * -3.3486e-2,
M_PI * -5.7408e-2
919 double *i_lsps,
const double *old,
920 double *
a1,
double *
a2,
int q_mode)
922 static const uint16_t vec_sizes[3] = { 128, 64, 64 };
923 static const double mul_lsf[3] = {
924 2.5807601174e-3, 1.2354460219e-3, 1.1763821673e-3
926 static const double base_lsf[3] = {
927 M_PI * -1.07448e-1,
M_PI * -5.2706e-2,
M_PI * -5.1634e-2
929 const float (*ipol_tab)[2][10] = q_mode ?
941 for (n = 0; n < 10; n++) {
942 double delta = old[n] - i_lsps[n];
956 static const uint16_t vec_sizes[5] = { 256, 64, 128, 64, 128 };
957 static const double mul_lsf[5] = {
958 3.3439586280e-3, 6.9908173703e-4,
959 3.3216608306e-3, 1.0334960326e-3,
962 static const double base_lsf[5] = {
963 M_PI * -1.27576e-1,
M_PI * -2.4292e-2,
964 M_PI * -1.28094e-1,
M_PI * -3.2128e-2,
988 double *i_lsps,
const double *old,
989 double *
a1,
double *
a2,
int q_mode)
991 static const uint16_t vec_sizes[3] = { 128, 128, 128 };
992 static const double mul_lsf[3] = {
993 1.2232979501e-3, 1.4062241527e-3, 1.6114744851e-3
995 static const double base_lsf[3] = {
998 const float (*ipol_tab)[2][16] = q_mode ?
1010 for (n = 0; n < 16; n++) {
1011 double delta = old[n] - i_lsps[n];
1040 static const int16_t start_offset[94] = {
1041 -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11,
1042 13, 15, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26,
1043 27, 28, 29, 30, 31, 32, 33, 35, 37, 39, 41, 43,
1044 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
1045 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
1046 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115,
1047 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139,
1048 141, 143, 145, 147, 149, 151, 153, 155, 157, 159
1053 s->aw_idx_is_ext = 0;
1055 s->aw_idx_is_ext = 1;
1061 s->aw_pulse_range =
FFMIN(pitch[0], pitch[1]) > 32 ? 24 : 16;
1064 s->aw_first_pulse_off[0] =
offset -
s->aw_pulse_range / 2;
1065 offset +=
s->aw_n_pulses[0] * pitch[0];
1073 while (
s->aw_first_pulse_off[1] - pitch[1] +
s->aw_pulse_range > 0)
1074 s->aw_first_pulse_off[1] -= pitch[1];
1075 if (start_offset[
bits] < 0)
1076 while (
s->aw_first_pulse_off[0] - pitch[0] +
s->aw_pulse_range > 0)
1077 s->aw_first_pulse_off[0] -= pitch[0];
1092 uint16_t use_mask_mem[9];
1093 uint16_t *use_mask = use_mask_mem + 2;
1101 int pulse_off =
s->aw_first_pulse_off[block_idx],
1102 pulse_start, n, idx, range, aidx, start_off = 0;
1105 if (
s->aw_n_pulses[block_idx] > 0)
1106 while (pulse_off +
s->aw_pulse_range < 1)
1110 if (
s->aw_n_pulses[0] > 0) {
1111 if (block_idx == 0) {
1115 if (
s->aw_n_pulses[block_idx] > 0)
1116 pulse_off =
s->aw_next_pulse_off_cache;
1120 pulse_start =
s->aw_n_pulses[block_idx] > 0 ? pulse_off - range / 2 : 0;
1125 memset(&use_mask[-2], 0, 2 *
sizeof(use_mask[0]));
1126 memset( use_mask, -1, 5 *
sizeof(use_mask[0]));
1127 memset(&use_mask[5], 0, 2 *
sizeof(use_mask[0]));
1128 if (
s->aw_n_pulses[block_idx] > 0)
1130 int excl_range =
s->aw_pulse_range;
1131 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
1132 int first_sh = 16 - (idx & 15);
1133 *use_mask_ptr++ &= 0xFFFFu << first_sh;
1134 excl_range -= first_sh;
1135 if (excl_range >= 16) {
1136 *use_mask_ptr++ = 0;
1137 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
1139 *use_mask_ptr &= 0xFFFF >> excl_range;
1143 aidx =
get_bits(gb,
s->aw_n_pulses[0] > 0 ? 5 - 2 * block_idx : 4);
1144 for (n = 0; n <= aidx; pulse_start++) {
1145 for (idx = pulse_start; idx < 0; idx += fcb->
pitch_lag) ;
1147 if (use_mask[0]) idx = 0x0F;
1148 else if (use_mask[1]) idx = 0x1F;
1149 else if (use_mask[2]) idx = 0x2F;
1150 else if (use_mask[3]) idx = 0x3F;
1151 else if (use_mask[4]) idx = 0x4F;
1155 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
1156 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
1162 fcb->
x[fcb->
n] = start_off;
1168 s->aw_next_pulse_off_cache = n ? fcb->
pitch_lag - n : 0;
1182 int val =
get_bits(gb, 12 - 2 * (
s->aw_idx_is_ext && !block_idx));
1185 if (
s->aw_n_pulses[block_idx] > 0) {
1186 int n, v_mask, i_mask, sh, n_pulses;
1188 if (
s->aw_pulse_range == 24) {
1200 for (n = n_pulses - 1; n >= 0; n--,
val >>= sh) {
1201 fcb->
y[fcb->
n] = (
val & v_mask) ? -1.0 : 1.0;
1202 fcb->
x[fcb->
n] = (
val & i_mask) * n_pulses + n +
1203 s->aw_first_pulse_off[block_idx];
1204 while (fcb->
x[fcb->
n] < 0)
1210 int num2 = (
val & 0x1FF) >> 1,
delta, idx;
1212 if (num2 < 1 * 79) {
delta = 1; idx = num2 + 1; }
1213 else if (num2 < 2 * 78) {
delta = 3; idx = num2 + 1 - 1 * 77; }
1214 else if (num2 < 3 * 77) {
delta = 5; idx = num2 + 1 - 2 * 76; }
1215 else {
delta = 7; idx = num2 + 1 - 3 * 75; }
1216 v = (
val & 0x200) ? -1.0 : 1.0;
1221 fcb->
x[fcb->
n + 1] = idx;
1222 fcb->
y[fcb->
n + 1] = (
val & 1) ? -v : v;
1240 static int pRNG(
int frame_cntr,
int block_num,
int block_size)
1252 static const unsigned int div_tbl[9][2] = {
1253 { 8332, 3 * 715827883U },
1254 { 4545, 0 * 390451573U },
1255 { 3124, 11 * 268435456U },
1256 { 2380, 15 * 204522253U },
1257 { 1922, 23 * 165191050U },
1258 { 1612, 23 * 138547333U },
1259 { 1388, 27 * 119304648U },
1260 { 1219, 16 * 104755300U },
1261 { 1086, 39 * 93368855U }
1263 unsigned int z, y, x =
MUL16(block_num, 1877) + frame_cntr;
1264 if (x >= 0xFFFF) x -= 0xFFFF;
1266 y = x - 9 *
MULH(477218589, x);
1267 z = (uint16_t) (x * div_tbl[y][0] +
UMULH(x, div_tbl[y][1]));
1269 return z % (1000 - block_size);
1277 int block_idx,
int size,
1288 r_idx =
pRNG(
s->frame_cntr, block_idx,
size);
1289 gain =
s->silence_gain;
1296 memset(
s->gain_pred_err, 0,
sizeof(
s->gain_pred_err));
1299 for (n = 0; n <
size; n++)
1308 int block_idx,
int size,
1309 int block_pitch_sh2,
1313 static const float gain_coeff[6] = {
1314 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
1317 int n, idx, gain_weight;
1336 int r_idx =
pRNG(
s->frame_cntr, block_idx,
size);
1338 for (n = 0; n <
size; n++)
1350 for (n = 0; n < 5; n++) {
1356 fcb.
x[fcb.
n] = n + 5 * pos1;
1357 fcb.
y[fcb.
n++] = sign;
1358 if (n < frame_desc->dbl_pulses) {
1360 fcb.
x[fcb.
n] = n + 5 * pos2;
1361 fcb.
y[fcb.
n++] = (pos1 < pos2) ? -sign : sign;
1379 memmove(&
s->gain_pred_err[gain_weight],
s->gain_pred_err,
1380 sizeof(*
s->gain_pred_err) * (6 - gain_weight));
1381 for (n = 0; n < gain_weight; n++)
1382 s->gain_pred_err[n] = pred_err;
1387 for (n = 0; n <
size; n +=
len) {
1389 int abs_idx = block_idx *
size + n;
1390 int pitch_sh16 = (
s->last_pitch_val << 16) +
1391 s->pitch_diff_sh16 * abs_idx;
1392 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
1393 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
1394 idx = idx_sh16 >> 16;
1395 if (
s->pitch_diff_sh16) {
1396 if (
s->pitch_diff_sh16 > 0) {
1397 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
1399 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
1400 len =
av_clip((idx_sh16 - next_idx_sh16) /
s->pitch_diff_sh16 / 8,
1410 int block_pitch = block_pitch_sh2 >> 2;
1411 idx = block_pitch_sh2 & 3;
1418 sizeof(
float) *
size);
1423 acb_gain, fcb_gain,
size);
1442 int block_idx,
int size,
1443 int block_pitch_sh2,
1444 const double *lsps,
const double *prev_lsps,
1446 float *excitation,
float *synth)
1457 frame_desc, excitation);
1460 fac = (block_idx + 0.5) / frame_desc->
n_blocks;
1461 for (n = 0; n <
s->lsps; n++)
1462 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
1485 const double *lsps,
const double *prev_lsps,
1486 float *excitation,
float *synth)
1489 int n, n_blocks_x2, log_n_blocks_x2,
av_uninit(cur_pitch_val);
1497 "Invalid frame type VLC code, skipping\n");
1511 cur_pitch_val =
s->min_pitch_val +
get_bits(gb,
s->pitch_nbits);
1512 cur_pitch_val =
FFMIN(cur_pitch_val,
s->max_pitch_val - 1);
1514 20 *
abs(cur_pitch_val -
s->last_pitch_val) >
1515 (cur_pitch_val +
s->last_pitch_val))
1516 s->last_pitch_val = cur_pitch_val;
1520 int fac = n * 2 + 1;
1522 pitch[n] = (
MUL16(fac, cur_pitch_val) +
1523 MUL16((n_blocks_x2 - fac),
s->last_pitch_val) +
1528 s->pitch_diff_sh16 =
1554 t1 = (
s->block_conv_table[1] -
s->block_conv_table[0]) << 2,
1555 t2 = (
s->block_conv_table[2] -
s->block_conv_table[1]) << 1,
1556 t3 =
s->block_conv_table[3] -
s->block_conv_table[2] + 1;
1559 block_pitch =
get_bits(gb,
s->block_pitch_nbits);
1561 block_pitch = last_block_pitch -
s->block_delta_pitch_hrange +
1562 get_bits(gb,
s->block_delta_pitch_nbits);
1564 last_block_pitch =
av_clip(block_pitch,
1565 s->block_delta_pitch_hrange,
1566 s->block_pitch_range -
1567 s->block_delta_pitch_hrange);
1570 if (block_pitch <
t1) {
1571 bl_pitch_sh2 = (
s->block_conv_table[0] << 2) + block_pitch;
1574 if (block_pitch <
t2) {
1576 (
s->block_conv_table[1] << 2) + (block_pitch << 1);
1579 if (block_pitch <
t3) {
1581 (
s->block_conv_table[2] + block_pitch) << 2;
1583 bl_pitch_sh2 =
s->block_conv_table[3] << 2;
1586 pitch[n] = bl_pitch_sh2 >> 2;
1591 bl_pitch_sh2 = pitch[n] << 2;
1602 &excitation[n * block_nsamples],
1603 &synth[n * block_nsamples]);
1612 for (n = 0; n <
s->lsps; n++)
1613 i_lsps[n] = cos(0.5 * (prev_lsps[n] + lsps[n]));
1619 for (n = 0; n <
s->lsps; n++)
1620 i_lsps[n] = cos(lsps[n]);
1623 &
s->zero_exc_pf[
s->history_nsamples +
MAX_FRAMESIZE * frame_idx + 80],
1626 memcpy(samples, synth, 160 *
sizeof(synth[0]));
1630 if (
s->frame_cntr >= 0xFFFF)
s->frame_cntr -= 0xFFFF;
1634 s->last_pitch_val = 0;
1637 s->last_pitch_val = cur_pitch_val;
1666 lsps[0] =
FFMAX(lsps[0], 0.0015 *
M_PI);
1667 for (n = 1; n < num; n++)
1668 lsps[n] =
FFMAX(lsps[n], lsps[n - 1] + 0.0125 *
M_PI);
1669 lsps[num - 1] =
FFMIN(lsps[num - 1], 0.9985 *
M_PI);
1673 for (n = 1; n < num; n++) {
1674 if (lsps[n] < lsps[n - 1]) {
1675 for (m = 1; m < num; m++) {
1676 double tmp = lsps[m];
1677 for (l = m - 1; l >= 0; l--) {
1678 if (lsps[l] <=
tmp)
break;
1679 lsps[l + 1] = lsps[l];
1712 const double *
mean_lsf =
s->lsps == 16 ?
1718 memcpy(synth,
s->synth_history,
1719 s->lsps *
sizeof(*synth));
1720 memcpy(excitation,
s->excitation_history,
1721 s->history_nsamples *
sizeof(*excitation));
1723 if (
s->sframe_cache_size > 0) {
1726 s->sframe_cache_size = 0;
1742 "Superframe encodes > %d samples (%d), not allowed\n",
1749 if (
s->has_residual_lsps) {
1752 for (n = 0; n <
s->lsps; n++)
1753 prev_lsps[n] =
s->prev_lsps[n] -
mean_lsf[n];
1755 if (
s->lsps == 10) {
1760 for (n = 0; n <
s->lsps; n++) {
1762 lsps[1][n] =
mean_lsf[n] + (
a1[
s->lsps + n] -
a2[n * 2 + 1]);
1765 for (n = 0; n < 3; n++)
1781 for (n = 0; n < 3; n++) {
1782 if (!
s->has_residual_lsps) {
1785 if (
s->lsps == 10) {
1790 for (m = 0; m <
s->lsps; m++)
1797 lsps[n], n == 0 ?
s->prev_lsps : lsps[n - 1],
1821 memcpy(
s->prev_lsps, lsps[2],
1822 s->lsps *
sizeof(*
s->prev_lsps));
1824 s->lsps *
sizeof(*synth));
1826 s->history_nsamples *
sizeof(*excitation));
1829 s->history_nsamples *
sizeof(*
s->zero_exc_pf));
1844 unsigned int res, n_superframes = 0;
1854 n_superframes += res;
1855 }
while (res == 0x3F);
1856 s->spillover_nbits =
get_bits(gb,
s->spillover_bitsize);
1880 int rmn_bytes, rmn_bits;
1883 if (rmn_bits < nbits)
1887 rmn_bits &= 7; rmn_bytes >>= 3;
1888 if ((rmn_bits =
FFMIN(rmn_bits, nbits)) > 0)
1891 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
1906 int *got_frame_ptr,
AVPacket *avpkt)
1923 if (!(
size %
ctx->block_align)) {
1925 s->spillover_nbits = 0;
1926 s->nb_superframes = 0;
1930 s->nb_superframes = res;
1936 if (
s->sframe_cache_size > 0) {
1938 if (cnt +
s->spillover_nbits > avpkt->
size * 8) {
1939 s->spillover_nbits = avpkt->
size * 8 - cnt;
1943 s->sframe_cache_size +=
s->spillover_nbits;
1946 cnt +=
s->spillover_nbits;
1947 s->skip_bits_next = cnt & 7;
1953 }
else if (
s->spillover_nbits) {
1956 }
else if (
s->skip_bits_next)
1960 s->sframe_cache_size = 0;
1961 s->skip_bits_next = 0;
1963 if (
s->nb_superframes-- == 0) {
1966 }
else if (
s->nb_superframes > 0) {
1969 }
else if (*got_frame_ptr) {
1971 s->skip_bits_next = cnt & 7;
1975 }
else if ((
s->sframe_cache_size =
pos) > 0) {
static void flush(AVCodecContext *avctx)
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
void ff_acelp_apply_order_2_transfer_function(float *out, const float *in, const float zero_coeffs[2], const float pole_coeffs[2], float gain, float mem[2], int n)
Apply an order 2 rational transfer function in-place.
void ff_acelp_interpolatef(float *out, const float *in, const float *filter_coeffs, int precision, int frac_pos, int filter_length, int length)
Floating point version of ff_acelp_interpolate()
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
void ff_weighted_vector_sumf(float *out, const float *in_a, const float *in_b, float weight_coeff_a, float weight_coeff_b, int length)
float implementation of weighted sum of two vectors.
static double val(void *priv, double ch)
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
#define flags(name, subs,...)
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
void ff_celp_lp_zero_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP zero synthesis filter.
audio channel layout utility functions
static __device__ float fabsf(float a)
av_cold int ff_dct_init(DCTContext *s, int nbits, enum DCTTransformType inverse)
Set up DCT.
av_cold void ff_dct_end(DCTContext *s)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static float mul(float src0, float src1)
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
bitstream reader API header.
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static int get_bits_left(GetBitContext *gb)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int get_bits_count(const GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define AV_CH_LAYOUT_MONO
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time,...
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
static const int16_t alpha[]
static const int sizes[][2]
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static int ff_thread_once(char *control, void(*routine)(void))
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
static av_always_inline unsigned UMULH(unsigned a, unsigned b)
static const uint16_t table[]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static int put_bits_count(PutBitContext *s)
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static const uint8_t last_coeff[3]
av_cold int ff_rdft_init(RDFTContext *s, int nbits, enum RDFTransformType trans)
Set up a real FFT.
av_cold void ff_rdft_end(RDFTContext *s)
void ff_sine_window_init(float *window, int n)
Generate a sine window.
static const float mean_lsf[10]
Sparse representation for the algebraic codebook (fixed) vector.
main external API structure.
const char * name
Name of the codec implementation.
void * priv_data
Format private data.
This structure describes decoded (raw) audio or video data.
int nb_samples
number of audio samples (per channel) described by this frame
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
This structure stores compressed data.
VLC_TYPE(* table)[2]
code, bits
WMA Voice decoding context.
int nb_superframes
number of superframes in current packet
int aw_first_pulse_off[2]
index of first sample to which to apply AW-pulses, or -0xff if unset
float dcf_mem[2]
DC filter history.
float denoise_filter_cache[MAX_FRAMESIZE]
int lsp_q_mode
defines quantizer defaults [0, 1]
int pitch_nbits
number of bits used to specify the pitch value in the frame header
int last_pitch_val
pitch value of the previous frame
uint16_t block_conv_table[4]
boundaries for block pitch unit/scale conversion
int block_pitch_nbits
number of bits used to specify the first block's pitch value
int last_acb_type
frame type [0-2] of the previous frame
float zero_exc_pf[MAX_SIGNAL_HISTORY+MAX_SFRAMESIZE]
zero filter output (i.e.
DCTContext dst
contexts for phase shift (in Hilbert transform, part of postfilter)
int sframe_cache_size
set to >0 if we have data from an (incomplete) superframe from a previous packet that spilled over in...
int aw_idx_is_ext
whether the AW index was encoded in 8 bits (instead of 6)
int8_t vbm_tree[25]
converts VLC codes to frame type
uint8_t sframe_cache[SFRAME_CACHE_MAXSIZE+AV_INPUT_BUFFER_PADDING_SIZE]
cache for superframe data split over multiple packets
GetBitContext gb
packet bitreader.
int denoise_tilt_corr
Whether to apply tilt correction to the Wiener filter coefficients (postfilter)
float denoise_coeffs_pf[0x80]
aligned buffer for denoise coefficients
int lsps
number of LSPs per frame [10 or 16]
float postfilter_agc
gain control memory, used in adaptive_gain_control()
float synth_history[MAX_LSPS]
see excitation_history
float silence_gain
set for use in blocks if ACB_TYPE_NONE
int block_pitch_range
range of the block pitch
float tilted_lpcs_pf[0x80]
aligned buffer for LPC tilting
int frame_cntr
current frame index [0 - 0xFFFE]; is only used for comfort noise in pRNG()
int max_pitch_val
max value + 1 for pitch parsing
int block_delta_pitch_nbits
number of bits used to specify the delta pitch between this and the last block's pitch value,...
float excitation_history[MAX_SIGNAL_HISTORY]
cache of the signal of previous superframes, used as a history for signal generation
int do_apf
whether to apply the averaged projection filter (APF)
int pitch_diff_sh16
((cur_pitch_val - last_pitch_val) << 16) / MAX_FRAMESIZE
int lsp_def_mode
defines different sets of LSP defaults [0, 1]
int history_nsamples
number of samples in history for signal prediction (through ACB)
float gain_pred_err[6]
cache for gain prediction
int has_residual_lsps
if set, superframes contain one set of LSPs that cover all frames, encoded as independent and residua...
int denoise_filter_cache_size
samples in denoise_filter_cache
float cos[511]
8-bit cosine/sine windows over [-pi,pi] range
int aw_next_pulse_off_cache
the position (relative to start of the second block) at which pulses should start to be positioned,...
int block_delta_pitch_hrange
1/2 range of the delta (full range is from -this to +this-1)
float synth_filter_out_buf[0x80+MAX_LSPS_ALIGN16]
aligned buffer for postfilter speech synthesis
int denoise_strength
strength of denoising in Wiener filter [0-11]
int spillover_bitsize
number of bits used to specify spillover_nbits in the packet header = ceil(log2(ctx->block_align << 3...
int spillover_nbits
number of bits of the previous packet's last superframe preceding this packet's first full superframe...
int skip_bits_next
number of bits to skip at the next call to wmavoice_decode_packet() (since they're part of the previo...
int min_pitch_val
base value for pitch parsing code
int aw_pulse_range
the range over which aw_pulse_set1() can apply the pulse, relative to the value in aw_first_pulse_off...
RDFTContext irdft
contexts for FFT-calculation in the postfilter (for denoise filter)
int dc_level
Predicted amount of DC noise, based on which a DC removal filter is used.
PutBitContext pb
bitstream writer for sframe_cache
int aw_n_pulses[2]
number of AW-pulses in each block; note that this number can be negative (in which case it basically ...
double prev_lsps[MAX_LSPS]
LSPs of the last frame of the previous superframe.
Description of frame types.
uint8_t log_n_blocks
log2(n_blocks)
uint8_t acb_type
Adaptive codebook type (ACB_TYPE_*)
uint8_t dbl_pulses
how many pulse vectors have pulse pairs (rather than just one single pulse) only if fcb_type == FCB_T...
uint8_t fcb_type
Fixed codebook type (FCB_TYPE_*)
uint8_t n_blocks
amount of blocks per frame (each block (contains 160/n_blocks samples)
#define avpriv_request_sample(...)
static const uint8_t offset[127][2]
#define INIT_VLC_STATIC(vlc, bits, a, b, c, d, e, f, g, static_size)
static int interpol(MBContext *s, uint32_t *color, int x, int y, int linesize)
static void dequant_lsp16r(GetBitContext *gb, double *i_lsps, const double *old, double *a1, double *a2, int q_mode)
Parse 16 independently-coded LSPs, and then derive the tables to generate LSPs for the other frames f...
@ ACB_TYPE_HAMMING
Per-block pitch with signal generation using a Hamming sinc window function.
@ ACB_TYPE_ASYMMETRIC
adaptive codebook with per-frame pitch, which we interpolate to get a per-sample pitch.
@ ACB_TYPE_NONE
no adaptive codebook (only hardcoded fixed)
static av_cold int decode_vbmtree(GetBitContext *gb, int8_t vbm_tree[25])
Set up the variable bit mode (VBM) tree from container extradata.
static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
Set up decoder with parameters from demuxer (extradata etc.).
static void aw_parse_coords(WMAVoiceContext *s, GetBitContext *gb, const int *pitch)
Parse the offset of the first pitch-adaptive window pulses, and the distribution of pulses between th...
static int aw_pulse_set2(WMAVoiceContext *s, GetBitContext *gb, int block_idx, AMRFixed *fcb)
Apply second set of pitch-adaptive window pulses.
static const struct frame_type_desc frame_descs[17]
@ FCB_TYPE_AW_PULSES
Pitch-adaptive window (AW) pulse signals, used in particular for low-bitrate streams.
@ FCB_TYPE_SILENCE
comfort noise during silence generated from a hardcoded (fixed) codebook with per-frame (low) gain va...
@ FCB_TYPE_HARDCODED
hardcoded (fixed) codebook with per-block gain values
@ FCB_TYPE_EXC_PULSES
Innovation (fixed) codebook pulse sets in combinations of either single pulses or pulse pairs.
#define SFRAME_CACHE_MAXSIZE
maximum cache size for frame data that
static void calc_input_response(WMAVoiceContext *s, float *lpcs, int fcb_type, float *coeffs, int remainder)
Derive denoise filter coefficients (in real domain) from the LPCs.
static void synth_block_fcb_acb(WMAVoiceContext *s, GetBitContext *gb, int block_idx, int size, int block_pitch_sh2, const struct frame_type_desc *frame_desc, float *excitation)
Parse FCB/ACB signal for a single block.
static av_cold int wmavoice_decode_end(AVCodecContext *ctx)
#define MAX_LSPS_ALIGN16
same as MAX_LSPS; needs to be multiple
static int synth_superframe(AVCodecContext *ctx, AVFrame *frame, int *got_frame_ptr)
Synthesize output samples for a single superframe.
static float tilt_factor(const float *lpcs, int n_lpcs)
Get the tilt factor of a formant filter from its transfer function.
static void dequant_lsp10i(GetBitContext *gb, double *lsps)
Parse 10 independently-coded LSPs.
static int synth_frame(AVCodecContext *ctx, GetBitContext *gb, int frame_idx, float *samples, const double *lsps, const double *prev_lsps, float *excitation, float *synth)
Synthesize output samples for a single frame.
static void dequant_lsp16i(GetBitContext *gb, double *lsps)
Parse 16 independently-coded LSPs.
static void dequant_lsp10r(GetBitContext *gb, double *i_lsps, const double *old, double *a1, double *a2, int q_mode)
Parse 10 independently-coded LSPs, and then derive the tables to generate LSPs for the other frames f...
static int parse_packet_header(WMAVoiceContext *s)
Parse the packet header at the start of each packet (input data to this decoder).
#define MAX_FRAMES
maximum number of frames per superframe
static void wiener_denoise(WMAVoiceContext *s, int fcb_type, float *synth_pf, int size, const float *lpcs)
This function applies a Wiener filter on the (noisy) speech signal as a means to denoise it.
static int kalman_smoothen(WMAVoiceContext *s, int pitch, const float *in, float *out, int size)
Kalman smoothing function.
static void copy_bits(PutBitContext *pb, const uint8_t *data, int size, GetBitContext *gb, int nbits)
Copy (unaligned) bits from gb/data/size to pb.
static VLC frame_type_vlc
Frame type VLC coding.
#define MAX_SIGNAL_HISTORY
maximum excitation signal history
static void adaptive_gain_control(float *out, const float *in, const float *speech_synth, int size, float alpha, float *gain_mem)
Adaptive gain control (as used in postfilter).
static av_cold void wmavoice_flush(AVCodecContext *ctx)
#define VLC_NBITS
number of bits to read per VLC iteration
#define log_range(var, assign)
static void postfilter(WMAVoiceContext *s, const float *synth, float *samples, int size, const float *lpcs, float *zero_exc_pf, int fcb_type, int pitch)
Averaging projection filter, the postfilter used in WMAVoice.
static void dequant_lsps(double *lsps, int num, const uint16_t *values, const uint16_t *sizes, int n_stages, const uint8_t *table, const double *mul_q, const double *base_q)
Dequantize LSPs.
static void stabilize_lsps(double *lsps, int num)
Ensure minimum value for first item, maximum value for last value, proper spacing between each value ...
#define MAX_BLOCKS
maximum number of blocks per frame
static av_cold void wmavoice_init_static_data(void)
#define MAX_SFRAMESIZE
maximum number of samples per superframe
static int pRNG(int frame_cntr, int block_num, int block_size)
Generate a random number from frame_cntr and block_idx, which will live in the range [0,...
static void synth_block_hardcoded(WMAVoiceContext *s, GetBitContext *gb, int block_idx, int size, const struct frame_type_desc *frame_desc, float *excitation)
Parse hardcoded signal for a single block.
static void aw_pulse_set1(WMAVoiceContext *s, GetBitContext *gb, int block_idx, AMRFixed *fcb)
Apply first set of pitch-adaptive window pulses.
#define MAX_FRAMESIZE
maximum number of samples per frame
static int wmavoice_decode_packet(AVCodecContext *ctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Packet decoding: a packet is anything that the (ASF) demuxer contains, and we expect that the demuxer...
static void synth_block(WMAVoiceContext *s, GetBitContext *gb, int block_idx, int size, int block_pitch_sh2, const double *lsps, const double *prev_lsps, const struct frame_type_desc *frame_desc, float *excitation, float *synth)
Parse data in a single block.
AVCodec ff_wmavoice_decoder
#define MAX_LSPS
maximum filter order
Windows Media Voice (WMAVoice) tables.
static const uint8_t wmavoice_dq_lsp16i3[0x300]
static const float wmavoice_ipol1_coeffs[17 *9]
static const float wmavoice_ipol2_coeffs[32]
Hamming-window sinc function (num = 32, x = [ 0, 31 ]): (0.54 + 0.46 * cos(2 * M_PI * x / (num - 1)))...
static const uint8_t wmavoice_dq_lsp10r[0x1400]
static const uint8_t wmavoice_dq_lsp10i[0xf00]
static const float wmavoice_gain_universal[64]
static const uint8_t wmavoice_dq_lsp16i1[0x640]
static const float wmavoice_gain_codebook_fcb[128]
static const float wmavoice_lsp16_intercoeff_b[32][2][16]
static const uint8_t wmavoice_dq_lsp16r3[0x600]
static const float wmavoice_denoise_power_table[12][64]
LUT for f(x,y) = pow((y + 6.9) / 64, 0.025 * (x + 1)).
static const uint8_t wmavoice_dq_lsp16i2[0x3c0]
static const float wmavoice_energy_table[128]
LUT for 1.071575641632 * pow(1.0331663, n - 127)
static const float wmavoice_lsp10_intercoeff_b[32][2][10]
static const float wmavoice_gain_silence[256]
static const uint8_t wmavoice_dq_lsp16r1[0x500]
static const uint8_t wmavoice_dq_lsp16r2[0x500]
static const float wmavoice_lsp10_intercoeff_a[32][2][10]
static const double wmavoice_mean_lsf16[2][16]
static const double wmavoice_mean_lsf10[2][10]
static const float wmavoice_lsp16_intercoeff_a[32][2][16]
static const float wmavoice_std_codebook[1000]
static const float wmavoice_gain_codebook_acb[128]