Go to the documentation of this file.
50 #define MAX_LSPS_ALIGN16 16
53 #define MAX_FRAMESIZE 160
54 #define MAX_SIGNAL_HISTORY 416
55 #define MAX_SFRAMESIZE (MAX_FRAMESIZE * MAX_FRAMES)
57 #define SFRAME_CACHE_MAXSIZE 256
303 int cntr[8] = { 0 }, n, res;
305 memset(vbm_tree, 0xff,
sizeof(vbm_tree[0]) * 25);
306 for (n = 0; n < 17; n++) {
310 vbm_tree[res * 3 + cntr[res]++] = n;
317 static const uint8_t
bits[] = {
320 10, 10, 10, 12, 12, 12,
326 1,
NULL, 0, 0, 0, 0);
334 s->postfilter_agc = 0;
335 s->sframe_cache_size = 0;
336 s->skip_bits_next = 0;
337 for (n = 0; n <
s->lsps; n++)
338 s->prev_lsps[n] =
M_PI * (n + 1.0) / (
s->lsps + 1.0);
339 memset(
s->excitation_history, 0,
341 memset(
s->synth_history, 0,
343 memset(
s->gain_pred_err, 0,
344 sizeof(
s->gain_pred_err));
348 sizeof(*
s->synth_filter_out_buf) *
s->lsps);
349 memset(
s->dcf_mem, 0,
350 sizeof(*
s->dcf_mem) * 2);
351 memset(
s->zero_exc_pf, 0,
352 sizeof(*
s->zero_exc_pf) *
s->history_nsamples);
353 memset(
s->denoise_filter_cache, 0,
sizeof(
s->denoise_filter_cache));
363 int n,
flags, pitch_range, lsp16_flag,
ret;
376 if (
ctx->extradata_size != 46) {
378 "Invalid extradata size %d (should be 46)\n",
379 ctx->extradata_size);
382 if (
ctx->block_align <= 0 ||
ctx->block_align > (1<<22)) {
401 scale = 1.0 / (1 << 6);
406 scale = 1.0 / (1 << 6);
412 memcpy(&
s->sin[255],
s->cos, 256 *
sizeof(
s->cos[0]));
413 for (n = 0; n < 255; n++) {
414 s->sin[n] = -
s->sin[510 - n];
415 s->cos[510 - n] =
s->cos[n];
418 s->denoise_strength = (
flags >> 2) & 0xF;
419 if (
s->denoise_strength >= 12) {
421 "Invalid denoise filter strength %d (max=11)\n",
422 s->denoise_strength);
425 s->denoise_tilt_corr = !!(
flags & 0x40);
426 s->dc_level = (
flags >> 7) & 0xF;
427 s->lsp_q_mode = !!(
flags & 0x2000);
428 s->lsp_def_mode = !!(
flags & 0x4000);
429 lsp16_flag =
flags & 0x1000;
435 for (n = 0; n <
s->lsps; n++)
436 s->prev_lsps[n] =
M_PI * (n + 1.0) / (
s->lsps + 1.0);
444 if (
ctx->sample_rate >= INT_MAX / (256 * 37))
447 s->min_pitch_val = ((
ctx->sample_rate << 8) / 400 + 50) >> 8;
448 s->max_pitch_val = ((
ctx->sample_rate << 8) * 37 / 2000 + 50) >> 8;
449 pitch_range =
s->max_pitch_val -
s->min_pitch_val;
450 if (pitch_range <= 0) {
455 s->last_pitch_val = 40;
457 s->history_nsamples =
s->max_pitch_val + 8;
460 int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
464 "Unsupported samplerate %d (min=%d, max=%d)\n",
465 ctx->sample_rate, min_sr, max_sr);
470 s->block_conv_table[0] =
s->min_pitch_val;
471 s->block_conv_table[1] = (pitch_range * 25) >> 6;
472 s->block_conv_table[2] = (pitch_range * 44) >> 6;
473 s->block_conv_table[3] =
s->max_pitch_val - 1;
474 s->block_delta_pitch_hrange = (pitch_range >> 3) & ~0xF;
475 if (
s->block_delta_pitch_hrange <= 0) {
479 s->block_delta_pitch_nbits = 1 +
av_ceil_log2(
s->block_delta_pitch_hrange);
480 s->block_pitch_range =
s->block_conv_table[2] +
481 s->block_conv_table[3] + 1 +
482 2 * (
s->block_conv_table[1] - 2 *
s->min_pitch_val);
514 const float *speech_synth,
518 float speech_energy = 0.0, postfilter_energy = 0.0, gain_scale_factor;
519 float mem = *gain_mem;
522 speech_energy +=
fabsf(speech_synth[
i]);
523 postfilter_energy +=
fabsf(in[
i]);
525 gain_scale_factor = postfilter_energy == 0.0 ? 0.0 :
526 (1.0 -
alpha) * speech_energy / postfilter_energy;
529 mem =
alpha * mem + gain_scale_factor;
530 out[
i] = in[
i] * mem;
555 const float *in,
float *
out,
int size)
558 float optimal_gain = 0, dot;
559 const float *ptr = &in[-
FFMAX(
s->min_pitch_val, pitch - 3)],
560 *end = &in[-
FFMIN(
s->max_pitch_val, pitch + 3)],
561 *best_hist_ptr =
NULL;
566 if (dot > optimal_gain) {
570 }
while (--ptr >= end);
572 if (optimal_gain <= 0)
578 if (optimal_gain <= dot) {
579 dot = dot / (dot + 0.6 * optimal_gain);
584 for (n = 0; n <
size; n++)
585 out[n] = best_hist_ptr[n] + dot * (in[n] - best_hist_ptr[n]);
614 int fcb_type,
float *coeffs_dst,
int remainder)
617 float irange, angle_mul, gain_mul,
range, sq;
623 memcpy(coeffs, coeffs_dst, 0x82*
sizeof(
float));
626 s->rdft_fn(
s->rdft, lpcs, lpcs_src,
sizeof(
float));
627 #define log_range(var, assign) do { \
628 float tmp = log10f(assign); var = tmp; \
629 max = FFMAX(max, tmp); min = FFMIN(min, tmp); \
632 for (n = 1; n < 64; n++)
633 log_range(lpcs[n], lpcs[n * 2] * lpcs[n * 2] +
634 lpcs[n * 2 + 1] * lpcs[n * 2 + 1]);
645 irange = 64.0 /
range;
649 for (n = 0; n <= 64; n++) {
652 idx =
lrint((
max - lpcs[n]) * irange - 1);
655 lpcs[n] = angle_mul * pwr;
658 idx =
av_clipd((pwr * gain_mul - 0.0295) * 70.570526123, 0, INT_MAX / 2);
662 powf(1.0331663, idx - 127);
671 s->dct_fn(
s->dct, lpcs_dct, lpcs,
sizeof(
float));
672 s->dst_fn(
s->dst, lpcs, lpcs_dct,
sizeof(
float));
675 idx = 255 +
av_clip(lpcs[64], -255, 255);
676 coeffs[0] = coeffs[0] *
s->cos[idx];
677 idx = 255 +
av_clip(lpcs[64] - 2 * lpcs[63], -255, 255);
680 idx = 255 +
av_clip(-lpcs[64] - 2 * lpcs[n - 1], -255, 255);
681 coeffs[n * 2 + 1] = coeffs[n] *
s->sin[idx];
682 coeffs[n * 2] = coeffs[n] *
s->cos[idx];
686 idx = 255 +
av_clip( lpcs[64] - 2 * lpcs[n - 1], -255, 255);
687 coeffs[n * 2 + 1] = coeffs[n] *
s->sin[idx];
688 coeffs[n * 2] = coeffs[n] *
s->cos[idx];
696 memset(&coeffs_dst[remainder], 0,
sizeof(coeffs_dst[0]) * (128 - remainder));
697 if (
s->denoise_tilt_corr) {
700 coeffs_dst[remainder - 1] = 0;
703 coeffs_dst, remainder);
707 for (n = 0; n < remainder; n++)
738 float *synth_pf,
int size,
741 int remainder, lim, n;
746 float *tilted_lpcs =
s->tilted_lpcs_pf,
747 *coeffs =
s->denoise_coeffs_pf, tilt_mem = 0;
749 tilted_lpcs[0] = 1.0;
750 memcpy(&tilted_lpcs[1], lpcs,
sizeof(lpcs[0]) *
s->lsps);
751 memset(&tilted_lpcs[
s->lsps + 1], 0,
752 sizeof(tilted_lpcs[0]) * (128 -
s->lsps - 1));
754 tilted_lpcs,
s->lsps + 2);
765 memset(&synth_pf[
size], 0,
sizeof(synth_pf[0]) * (128 -
size));
766 s->rdft_fn(
s->rdft, synth_f, synth_pf,
sizeof(
float));
767 s->rdft_fn(
s->rdft, coeffs_f, coeffs,
sizeof(
float));
768 synth_f[0] *= coeffs_f[0];
769 synth_f[1] *= coeffs_f[1];
770 for (n = 1; n <= 64; n++) {
771 float v1 = synth_f[n * 2], v2 = synth_f[n * 2 + 1];
772 synth_f[n * 2] = v1 * coeffs_f[n * 2] - v2 * coeffs_f[n * 2 + 1];
773 synth_f[n * 2 + 1] = v2 * coeffs_f[n * 2] + v1 * coeffs_f[n * 2 + 1];
779 if (
s->denoise_filter_cache_size) {
780 lim =
FFMIN(
s->denoise_filter_cache_size,
size);
781 for (n = 0; n < lim; n++)
782 synth_pf[n] +=
s->denoise_filter_cache[n];
783 s->denoise_filter_cache_size -= lim;
784 memmove(
s->denoise_filter_cache, &
s->denoise_filter_cache[
size],
785 sizeof(
s->denoise_filter_cache[0]) *
s->denoise_filter_cache_size);
790 lim =
FFMIN(remainder,
s->denoise_filter_cache_size);
791 for (n = 0; n < lim; n++)
792 s->denoise_filter_cache[n] += synth_pf[
size + n];
793 if (lim < remainder) {
794 memcpy(&
s->denoise_filter_cache[lim], &synth_pf[
size + lim],
795 sizeof(
s->denoise_filter_cache[0]) * (remainder - lim));
796 s->denoise_filter_cache_size = remainder;
823 const float *lpcs,
float *zero_exc_pf,
824 int fcb_type,
int pitch)
828 *synth_filter_in = zero_exc_pf;
837 synth_filter_in = synth_filter_in_buf;
841 synth_filter_in,
size,
s->lsps);
842 memcpy(&synth_pf[-
s->lsps], &synth_pf[
size -
s->lsps],
843 sizeof(synth_pf[0]) *
s->lsps);
850 if (
s->dc_level > 8) {
855 (
const float[2]) { -1.99997, 1.0 },
856 (
const float[2]) { -1.9330735188, 0.93589198496 },
857 0.93980580475,
s->dcf_mem,
size);
877 const uint16_t *
sizes,
878 int n_stages,
const uint8_t *
table,
880 const double *base_q)
884 memset(lsps, 0, num *
sizeof(*lsps));
885 for (n = 0; n < n_stages; n++) {
887 double base = base_q[n], mul = mul_q[n];
889 for (m = 0; m < num; m++)
890 lsps[m] +=
base + mul * t_off[m];
908 static const uint16_t vec_sizes[4] = { 256, 64, 32, 32 };
909 static const double mul_lsf[4] = {
910 5.2187144800e-3, 1.4626986422e-3,
911 9.6179549166e-4, 1.1325736225e-3
913 static const double base_lsf[4] = {
914 M_PI * -2.15522e-1,
M_PI * -6.1646e-2,
915 M_PI * -3.3486e-2,
M_PI * -5.7408e-2
933 double *i_lsps,
const double *old,
934 double *
a1,
double *
a2,
int q_mode)
936 static const uint16_t vec_sizes[3] = { 128, 64, 64 };
937 static const double mul_lsf[3] = {
938 2.5807601174e-3, 1.2354460219e-3, 1.1763821673e-3
940 static const double base_lsf[3] = {
941 M_PI * -1.07448e-1,
M_PI * -5.2706e-2,
M_PI * -5.1634e-2
943 const float (*ipol_tab)[2][10] = q_mode ?
955 for (n = 0; n < 10; n++) {
956 double delta = old[n] - i_lsps[n];
970 static const uint16_t vec_sizes[5] = { 256, 64, 128, 64, 128 };
971 static const double mul_lsf[5] = {
972 3.3439586280e-3, 6.9908173703e-4,
973 3.3216608306e-3, 1.0334960326e-3,
976 static const double base_lsf[5] = {
977 M_PI * -1.27576e-1,
M_PI * -2.4292e-2,
978 M_PI * -1.28094e-1,
M_PI * -3.2128e-2,
1002 double *i_lsps,
const double *old,
1003 double *
a1,
double *
a2,
int q_mode)
1005 static const uint16_t vec_sizes[3] = { 128, 128, 128 };
1006 static const double mul_lsf[3] = {
1007 1.2232979501e-3, 1.4062241527e-3, 1.6114744851e-3
1009 static const double base_lsf[3] = {
1010 M_PI * -5.5830e-2,
M_PI * -5.2908e-2,
M_PI * -5.4776e-2
1012 const float (*ipol_tab)[2][16] = q_mode ?
1024 for (n = 0; n < 16; n++) {
1025 double delta = old[n] - i_lsps[n];
1054 static const int16_t start_offset[94] = {
1055 -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11,
1056 13, 15, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26,
1057 27, 28, 29, 30, 31, 32, 33, 35, 37, 39, 41, 43,
1058 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
1059 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
1060 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115,
1061 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139,
1062 141, 143, 145, 147, 149, 151, 153, 155, 157, 159
1067 s->aw_idx_is_ext = 0;
1069 s->aw_idx_is_ext = 1;
1075 s->aw_pulse_range =
FFMIN(pitch[0], pitch[1]) > 32 ? 24 : 16;
1078 s->aw_first_pulse_off[0] =
offset -
s->aw_pulse_range / 2;
1079 offset +=
s->aw_n_pulses[0] * pitch[0];
1087 while (
s->aw_first_pulse_off[1] - pitch[1] +
s->aw_pulse_range > 0)
1088 s->aw_first_pulse_off[1] -= pitch[1];
1089 if (start_offset[
bits] < 0)
1090 while (
s->aw_first_pulse_off[0] - pitch[0] +
s->aw_pulse_range > 0)
1091 s->aw_first_pulse_off[0] -= pitch[0];
1106 uint16_t use_mask_mem[9];
1107 uint16_t *use_mask = use_mask_mem + 2;
1115 int pulse_off =
s->aw_first_pulse_off[block_idx],
1116 pulse_start, n, idx,
range, aidx, start_off = 0;
1119 if (
s->aw_n_pulses[block_idx] > 0)
1120 while (pulse_off +
s->aw_pulse_range < 1)
1124 if (
s->aw_n_pulses[0] > 0) {
1125 if (block_idx == 0) {
1129 if (
s->aw_n_pulses[block_idx] > 0)
1130 pulse_off =
s->aw_next_pulse_off_cache;
1134 pulse_start =
s->aw_n_pulses[block_idx] > 0 ? pulse_off -
range / 2 : 0;
1139 memset(&use_mask[-2], 0, 2 *
sizeof(use_mask[0]));
1140 memset( use_mask, -1, 5 *
sizeof(use_mask[0]));
1141 memset(&use_mask[5], 0, 2 *
sizeof(use_mask[0]));
1142 if (
s->aw_n_pulses[block_idx] > 0)
1144 int excl_range =
s->aw_pulse_range;
1145 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
1146 int first_sh = 16 - (idx & 15);
1147 *use_mask_ptr++ &= 0xFFFF
u << first_sh;
1148 excl_range -= first_sh;
1149 if (excl_range >= 16) {
1150 *use_mask_ptr++ = 0;
1151 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
1153 *use_mask_ptr &= 0xFFFF >> excl_range;
1157 aidx =
get_bits(gb,
s->aw_n_pulses[0] > 0 ? 5 - 2 * block_idx : 4);
1158 for (n = 0; n <= aidx; pulse_start++) {
1159 for (idx = pulse_start; idx < 0; idx += fcb->
pitch_lag) ;
1161 if (use_mask[0]) idx = 0x0F;
1162 else if (use_mask[1]) idx = 0x1F;
1163 else if (use_mask[2]) idx = 0x2F;
1164 else if (use_mask[3]) idx = 0x3F;
1165 else if (use_mask[4]) idx = 0x4F;
1169 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
1170 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
1176 fcb->
x[fcb->
n] = start_off;
1182 s->aw_next_pulse_off_cache = n ? fcb->
pitch_lag - n : 0;
1196 int val =
get_bits(gb, 12 - 2 * (
s->aw_idx_is_ext && !block_idx));
1199 if (
s->aw_n_pulses[block_idx] > 0) {
1200 int n, v_mask, i_mask, sh, n_pulses;
1202 if (
s->aw_pulse_range == 24) {
1214 for (n = n_pulses - 1; n >= 0; n--,
val >>= sh) {
1215 fcb->
y[fcb->
n] = (
val & v_mask) ? -1.0 : 1.0;
1216 fcb->
x[fcb->
n] = (
val & i_mask) * n_pulses + n +
1217 s->aw_first_pulse_off[block_idx];
1218 while (fcb->
x[fcb->
n] < 0)
1224 int num2 = (
val & 0x1FF) >> 1,
delta, idx;
1226 if (num2 < 1 * 79) {
delta = 1; idx = num2 + 1; }
1227 else if (num2 < 2 * 78) {
delta = 3; idx = num2 + 1 - 1 * 77; }
1228 else if (num2 < 3 * 77) {
delta = 5; idx = num2 + 1 - 2 * 76; }
1229 else {
delta = 7; idx = num2 + 1 - 3 * 75; }
1230 v = (
val & 0x200) ? -1.0 : 1.0;
1235 fcb->
x[fcb->
n + 1] = idx;
1236 fcb->
y[fcb->
n + 1] = (
val & 1) ? -v : v;
1254 static int pRNG(
int frame_cntr,
int block_num,
int block_size)
1266 static const unsigned int div_tbl[9][2] = {
1267 { 8332, 3 * 715827883
U },
1268 { 4545, 0 * 390451573
U },
1269 { 3124, 11 * 268435456
U },
1270 { 2380, 15 * 204522253
U },
1271 { 1922, 23 * 165191050
U },
1272 { 1612, 23 * 138547333
U },
1273 { 1388, 27 * 119304648
U },
1274 { 1219, 16 * 104755300
U },
1275 { 1086, 39 * 93368855
U }
1277 unsigned int z, y, x =
MUL16(block_num, 1877) + frame_cntr;
1278 if (x >= 0xFFFF) x -= 0xFFFF;
1280 y = x - 9 *
MULH(477218589, x);
1281 z = (uint16_t) (x * div_tbl[y][0] +
UMULH(x, div_tbl[y][1]));
1283 return z % (1000 - block_size);
1291 int block_idx,
int size,
1302 r_idx =
pRNG(
s->frame_cntr, block_idx,
size);
1303 gain =
s->silence_gain;
1310 memset(
s->gain_pred_err, 0,
sizeof(
s->gain_pred_err));
1313 for (n = 0; n <
size; n++)
1322 int block_idx,
int size,
1323 int block_pitch_sh2,
1327 static const float gain_coeff[6] = {
1328 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
1331 int n, idx, gain_weight;
1350 int r_idx =
pRNG(
s->frame_cntr, block_idx,
size);
1352 for (n = 0; n <
size; n++)
1364 for (n = 0; n < 5; n++) {
1370 fcb.
x[fcb.
n] = n + 5 * pos1;
1371 fcb.
y[fcb.
n++] = sign;
1372 if (n < frame_desc->dbl_pulses) {
1374 fcb.
x[fcb.
n] = n + 5 * pos2;
1375 fcb.
y[fcb.
n++] = (pos1 < pos2) ? -sign : sign;
1393 memmove(&
s->gain_pred_err[gain_weight],
s->gain_pred_err,
1394 sizeof(*
s->gain_pred_err) * (6 - gain_weight));
1395 for (n = 0; n < gain_weight; n++)
1396 s->gain_pred_err[n] = pred_err;
1401 for (n = 0; n <
size; n +=
len) {
1403 int abs_idx = block_idx *
size + n;
1404 int pitch_sh16 = (
s->last_pitch_val << 16) +
1405 s->pitch_diff_sh16 * abs_idx;
1406 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
1407 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
1408 idx = idx_sh16 >> 16;
1409 if (
s->pitch_diff_sh16) {
1410 if (
s->pitch_diff_sh16 > 0) {
1411 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
1413 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
1414 len =
av_clip((idx_sh16 - next_idx_sh16) /
s->pitch_diff_sh16 / 8,
1424 int block_pitch = block_pitch_sh2 >> 2;
1425 idx = block_pitch_sh2 & 3;
1432 sizeof(
float) *
size);
1437 acb_gain, fcb_gain,
size);
1456 int block_idx,
int size,
1457 int block_pitch_sh2,
1458 const double *lsps,
const double *prev_lsps,
1460 float *excitation,
float *synth)
1471 frame_desc, excitation);
1474 fac = (block_idx + 0.5) / frame_desc->
n_blocks;
1475 for (n = 0; n <
s->lsps; n++)
1476 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
1499 const double *lsps,
const double *prev_lsps,
1500 float *excitation,
float *synth)
1503 int n, n_blocks_x2, log_n_blocks_x2,
av_uninit(cur_pitch_val);
1513 "Invalid frame type VLC code, skipping\n");
1527 cur_pitch_val =
s->min_pitch_val +
get_bits(gb,
s->pitch_nbits);
1528 cur_pitch_val =
FFMIN(cur_pitch_val,
s->max_pitch_val - 1);
1530 20 *
abs(cur_pitch_val -
s->last_pitch_val) >
1531 (cur_pitch_val +
s->last_pitch_val))
1532 s->last_pitch_val = cur_pitch_val;
1536 int fac = n * 2 + 1;
1538 pitch[n] = (
MUL16(fac, cur_pitch_val) +
1539 MUL16((n_blocks_x2 - fac),
s->last_pitch_val) +
1544 s->pitch_diff_sh16 =
1570 t1 = (
s->block_conv_table[1] -
s->block_conv_table[0]) << 2,
1571 t2 = (
s->block_conv_table[2] -
s->block_conv_table[1]) << 1,
1572 t3 =
s->block_conv_table[3] -
s->block_conv_table[2] + 1;
1575 block_pitch =
get_bits(gb,
s->block_pitch_nbits);
1577 block_pitch = last_block_pitch -
s->block_delta_pitch_hrange +
1578 get_bits(gb,
s->block_delta_pitch_nbits);
1580 last_block_pitch =
av_clip(block_pitch,
1581 s->block_delta_pitch_hrange,
1582 s->block_pitch_range -
1583 s->block_delta_pitch_hrange);
1586 if (block_pitch < t1) {
1587 bl_pitch_sh2 = (
s->block_conv_table[0] << 2) + block_pitch;
1590 if (block_pitch < t2) {
1592 (
s->block_conv_table[1] << 2) + (block_pitch << 1);
1595 if (block_pitch < t3) {
1597 (
s->block_conv_table[2] + block_pitch) << 2;
1599 bl_pitch_sh2 =
s->block_conv_table[3] << 2;
1602 pitch[n] = bl_pitch_sh2 >> 2;
1607 bl_pitch_sh2 = pitch[n] << 2;
1618 &excitation[n * block_nsamples],
1619 &synth[n * block_nsamples]);
1631 for (n = 0; n <
s->lsps; n++)
1632 i_lsps[n] = cos(0.5 * (prev_lsps[n] + lsps[n]));
1638 for (n = 0; n <
s->lsps; n++)
1639 i_lsps[n] = cos(lsps[n]);
1642 &
s->zero_exc_pf[
s->history_nsamples +
MAX_FRAMESIZE * frame_idx + 80],
1645 memcpy(
samples, synth, 160 *
sizeof(synth[0]));
1649 if (
s->frame_cntr >= 0xFFFF)
s->frame_cntr -= 0xFFFF;
1653 s->last_pitch_val = 0;
1656 s->last_pitch_val = cur_pitch_val;
1685 lsps[0] =
FFMAX(lsps[0], 0.0015 *
M_PI);
1686 for (n = 1; n < num; n++)
1687 lsps[n] =
FFMAX(lsps[n], lsps[n - 1] + 0.0125 *
M_PI);
1688 lsps[num - 1] =
FFMIN(lsps[num - 1], 0.9985 *
M_PI);
1692 for (n = 1; n < num; n++) {
1693 if (lsps[n] < lsps[n - 1]) {
1694 for (m = 1; m < num; m++) {
1695 double tmp = lsps[m];
1696 for (l = m - 1; l >= 0; l--) {
1697 if (lsps[l] <=
tmp)
break;
1698 lsps[l + 1] = lsps[l];
1731 const double *
mean_lsf =
s->lsps == 16 ?
1737 memcpy(synth,
s->synth_history,
1738 s->lsps *
sizeof(*synth));
1739 memcpy(excitation,
s->excitation_history,
1740 s->history_nsamples *
sizeof(*excitation));
1742 if (
s->sframe_cache_size > 0) {
1745 s->sframe_cache_size = 0;
1761 "Superframe encodes > %d samples (%d), not allowed\n",
1768 if (
s->has_residual_lsps) {
1771 for (n = 0; n <
s->lsps; n++)
1772 prev_lsps[n] =
s->prev_lsps[n] -
mean_lsf[n];
1774 if (
s->lsps == 10) {
1779 for (n = 0; n <
s->lsps; n++) {
1781 lsps[1][n] =
mean_lsf[n] + (
a1[
s->lsps + n] -
a2[n * 2 + 1]);
1784 for (n = 0; n < 3; n++)
1796 frame->nb_samples = n_samples;
1800 for (n = 0; n < 3; n++) {
1801 if (!
s->has_residual_lsps) {
1804 if (
s->lsps == 10) {
1809 for (m = 0; m <
s->lsps; m++)
1816 lsps[n], n == 0 ?
s->prev_lsps : lsps[n - 1],
1840 memcpy(
s->prev_lsps, lsps[2],
1841 s->lsps *
sizeof(*
s->prev_lsps));
1843 s->lsps *
sizeof(*synth));
1845 s->history_nsamples *
sizeof(*excitation));
1848 s->history_nsamples *
sizeof(*
s->zero_exc_pf));
1863 unsigned int res, n_superframes = 0;
1873 n_superframes += res;
1874 }
while (res == 0x3F);
1875 s->spillover_nbits =
get_bits(gb,
s->spillover_bitsize);
1899 int rmn_bytes, rmn_bits;
1902 if (rmn_bits < nbits)
1906 rmn_bits &= 7; rmn_bytes >>= 3;
1907 if ((rmn_bits =
FFMIN(rmn_bits, nbits)) > 0)
1910 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
1925 int *got_frame_ptr,
AVPacket *avpkt)
1929 const uint8_t *buf = avpkt->
data;
1947 if (!(
size %
ctx->block_align)) {
1949 s->spillover_nbits = 0;
1950 s->nb_superframes = 0;
1954 s->nb_superframes = res;
1960 if (
s->sframe_cache_size > 0) {
1962 if (cnt +
s->spillover_nbits > avpkt->
size * 8) {
1963 s->spillover_nbits = avpkt->
size * 8 - cnt;
1967 s->sframe_cache_size +=
s->spillover_nbits;
1970 cnt +=
s->spillover_nbits;
1971 s->skip_bits_next = cnt & 7;
1977 }
else if (
s->spillover_nbits) {
1980 }
else if (
s->skip_bits_next)
1984 s->sframe_cache_size = 0;
1985 s->skip_bits_next = 0;
1987 if (
s->nb_superframes-- == 0) {
1990 }
else if (
s->nb_superframes > 0) {
1993 }
else if (*got_frame_ptr) {
1995 s->skip_bits_next = cnt & 7;
1999 }
else if ((
s->sframe_cache_size =
pos) > 0) {
2025 .
p.
name =
"wmavoice",
2034 #if FF_API_SUBFRAMES
2035 AV_CODEC_CAP_SUBFRAMES |
int has_residual_lsps
if set, superframes contain one set of LSPs that cover all frames, encoded as independent and residua...
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static const float wmavoice_std_codebook[1000]
static int interpol(MBContext *s, uint32_t *color, int x, int y, int linesize)
#define MAX_LSPS
maximum filter order
int aw_next_pulse_off_cache
the position (relative to start of the second block) at which pulses should start to be positioned,...
int max_pitch_val
max value + 1 for pitch parsing
static int aw_pulse_set2(WMAVoiceContext *s, GetBitContext *gb, int block_idx, AMRFixed *fcb)
Apply second set of pitch-adaptive window pulses.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static int get_bits_left(GetBitContext *gb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
@ FCB_TYPE_EXC_PULSES
Innovation (fixed) codebook pulse sets in combinations of either single pulses or pulse pairs.
static const uint8_t wmavoice_dq_lsp10i[0xf00]
float tilted_lpcs_pf[0x82]
aligned buffer for LPC tilting
#define u(width, name, range_min, range_max)
static const struct frame_type_desc frame_descs[17]
static const uint8_t wmavoice_dq_lsp16r3[0x600]
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 init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
float excitation_history[MAX_SIGNAL_HISTORY]
cache of the signal of previous superframes, used as a history for signal generation
static int get_bits_count(const GetBitContext *s)
int av_log2_16bit(unsigned v)
This structure describes decoded (raw) audio or video data.
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static void aw_pulse_set1(WMAVoiceContext *s, GetBitContext *gb, int block_idx, AMRFixed *fcb)
Apply first set of pitch-adaptive window pulses.
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.
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,...
const FFCodec ff_wmavoice_decoder
static const uint16_t table[]
float silence_gain
set for use in blocks if ACB_TYPE_NONE
int denoise_filter_cache_size
samples in denoise_filter_cache
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 float wmavoice_gain_codebook_acb[128]
void ff_celp_lp_synthesis_filterf(float *out, const float *filter_coeffs, const float *in, int buffer_length, int filter_length)
LP synthesis filter.
int aw_idx_is_ext
whether the AW index was encoded in 8 bits (instead of 6)
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
int dc_level
Predicted amount of DC noise, based on which a DC removal filter is used.
static const uint8_t wmavoice_dq_lsp16i1[0x640]
uint16_t block_conv_table[4]
boundaries for block pitch unit/scale conversion
uint8_t log_n_blocks
log2(n_blocks)
static void skip_bits(GetBitContext *s, int n)
int aw_pulse_range
the range over which aw_pulse_set1() can apply the pulse, relative to the value in aw_first_pulse_off...
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
AVCodec p
The public AVCodec.
static av_cold void wmavoice_flush(AVCodecContext *ctx)
static int put_bits_left(PutBitContext *s)
uint8_t n_blocks
amount of blocks per frame (each block (contains 160/n_blocks samples)
static double val(void *priv, double ch)
av_tx_fn irdft_fn
postfilter (for denoise filter)
static void dequant_lsp10i(GetBitContext *gb, double *lsps)
Parse 10 independently-coded LSPs.
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.
#define MAX_SFRAMESIZE
maximum number of samples per superframe
static const float wmavoice_gain_codebook_fcb[128]
static double a2(void *priv, double x, double y)
float denoise_filter_cache[MAX_FRAMESIZE]
static __device__ float fabsf(float a)
@ FCB_TYPE_AW_PULSES
Pitch-adaptive window (AW) pulse signals, used in particular for low-bitrate streams.
static void calc_input_response(WMAVoiceContext *s, float *lpcs_src, int fcb_type, float *coeffs_dst, int remainder)
Derive denoise filter coefficients (in real domain) from the LPCs.
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define FF_ARRAY_ELEMS(a)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
#define MAX_LSPS_ALIGN16
same as MAX_LSPS; needs to be multiple
void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)
Function pointer to a function to perform the transform.
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
static const uint8_t wmavoice_dq_lsp10r[0x1400]
#define FF_CODEC_DECODE_CB(func)
int sframe_cache_size
set to >0 if we have data from an (incomplete) superframe from a previous packet that spilled over in...
AVTXContext * dst
contexts for phase shift (in Hilbert
int lsp_q_mode
defines quantizer defaults [0, 1]
uint8_t fcb_type
Fixed codebook type (FCB_TYPE_*)
#define log_range(var, assign)
double prev_lsps[MAX_LSPS]
LSPs of the last frame of the previous superframe.
int aw_n_pulses[2]
number of AW-pulses in each block; note that this number can be negative (in which case it basically ...
Sparse representation for the algebraic codebook (fixed) vector.
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).
#define av_assert0(cond)
assert() equivalent, that is always enabled.
static const float wmavoice_lsp16_intercoeff_a[32][2][16]
static const double wmavoice_mean_lsf10[2][10]
int spillover_nbits
number of bits of the previous packet's last superframe preceding this packet's first full superframe...
static av_always_inline unsigned UMULH(unsigned a, unsigned b)
@ ACB_TYPE_ASYMMETRIC
adaptive codebook with per-frame pitch, which we interpolate to get a per-sample pitch.
float denoise_coeffs_pf[0x82]
aligned buffer for denoise coefficients
@ FCB_TYPE_SILENCE
comfort noise during silence generated from a hardcoded (fixed) codebook with per-frame (low) gain va...
static const float wmavoice_gain_silence[256]
int8_t vbm_tree[25]
converts VLC codes to frame type
#define CODEC_LONG_NAME(str)
static const uint8_t wmavoice_dq_lsp16i3[0x300]
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 const int sizes[][2]
int history_nsamples
number of samples in history for signal prediction (through ACB)
float synth_history[MAX_LSPS]
see excitation_history
#define LOCAL_ALIGNED_32(t, v,...)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static const uint8_t last_coeff[3]
int denoise_strength
strength of denoising in Wiener filter [0-11]
#define MAX_SIGNAL_HISTORY
maximum excitation signal history
uint8_t sframe_cache[SFRAME_CACHE_MAXSIZE+AV_INPUT_BUFFER_PADDING_SIZE]
cache for superframe data split over multiple packets
static unsigned int get_bits1(GetBitContext *s)
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...
int pitch_nbits
number of bits used to specify the pitch value in the frame header
int block_delta_pitch_nbits
number of bits used to specify the delta pitch between this and the last block's pitch value,...
static int kalman_smoothen(WMAVoiceContext *s, int pitch, const float *in, float *out, int size)
Kalman smoothing function.
int skip_bits_next
number of bits to skip at the next call to wmavoice_decode_packet() (since they're part of the previo...
static __device__ float sqrtf(float a)
av_tx_fn dst_fn
transform, part of postfilter)
#define MAX_FRAMESIZE
maximum number of samples per frame
#define MAX_FRAMES
maximum number of frames per superframe
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
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 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 av_cold void wmavoice_init_static_data(void)
float dcf_mem[2]
DC filter history.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
static int parse_packet_header(WMAVoiceContext *s)
Parse the packet header at the start of each packet (input data to this decoder).
@ AV_TX_FLOAT_DCT_I
Discrete Cosine Transform I.
An AVChannelLayout holds information about the channel layout of audio data.
#define DECLARE_ALIGNED(n, t, v)
int spillover_bitsize
number of bits used to specify spillover_nbits in the packet header = ceil(log2(ctx->block_align << 3...
PutBitContext pb
bitstream writer for sframe_cache
int last_pitch_val
pitch value of the previous frame
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 const float wmavoice_lsp10_intercoeff_b[32][2][10]
static void dequant_lsp16i(GetBitContext *gb, double *lsps)
Parse 16 independently-coded LSPs.
static const uint8_t wmavoice_dq_lsp16r1[0x500]
int aw_first_pulse_off[2]
index of first sample to which to apply AW-pulses, or -0xff if unset
float zero_exc_pf[MAX_SIGNAL_HISTORY+MAX_SFRAMESIZE]
zero filter output (i.e.
static const uint8_t wmavoice_dq_lsp16r2[0x500]
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Description of frame types.
int block_pitch_range
range of the block pitch
static void stabilize_lsps(double *lsps, int num)
Ensure minimum value for first item, maximum value for last value, proper spacing between each value ...
void ff_tilt_compensation(float *mem, float tilt, float *samples, int size)
Apply tilt compensation filter, 1 - tilt * z-1.
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
@ FCB_TYPE_HARDCODED
hardcoded (fixed) codebook with per-block gain values
static const float wmavoice_energy_table[128]
LUT for 1.071575641632 * pow(1.0331663, n - 127)
void ff_sine_window_init(float *window, int n)
Generate a sine window.
static av_cold int wmavoice_decode_init(AVCodecContext *ctx)
Set up decoder with parameters from demuxer (extradata etc.).
int block_delta_pitch_hrange
1/2 range of the delta (full range is from -this to +this-1)
@ ACB_TYPE_HAMMING
Per-block pitch with signal generation using a Hamming sinc window function.
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)))...
int pitch_diff_sh16
((cur_pitch_val - last_pitch_val) << 16) / MAX_FRAMESIZE
float gain_pred_err[6]
cache for gain prediction
#define i(width, name, range_min, range_max)
int nb_superframes
number of superframes in current packet
float cos[511]
8-bit cosine/sine windows over [-pi,pi] range
int denoise_tilt_corr
Whether to apply tilt correction to the Wiener filter coefficients (postfilter)
static const float wmavoice_lsp16_intercoeff_b[32][2][16]
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
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.
int lsp_def_mode
defines different sets of LSP defaults [0, 1]
static const float wmavoice_gain_universal[64]
const char * name
Name of the codec implementation.
float synth_filter_out_buf[0x80+MAX_LSPS_ALIGN16]
aligned buffer for postfilter speech synthesis
static float tilt_factor(const float *lpcs, int n_lpcs)
Get the tilt factor of a formant filter from its transfer function.
#define VLC_NBITS
number of bits to read per VLC iteration
Windows Media Voice (WMAVoice) tables.
int min_pitch_val
base value for pitch parsing code
int last_acb_type
frame type [0-2] of the previous frame
@ ACB_TYPE_NONE
no adaptive codebook (only hardcoded fixed)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
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.
int do_apf
whether to apply the averaged projection filter (APF)
static const uint8_t wmavoice_dq_lsp16i2[0x3c0]
#define AV_INPUT_BUFFER_PADDING_SIZE
static const double wmavoice_mean_lsf16[2][16]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
@ AV_TX_FLOAT_RDFT
Real to complex and complex to real DFTs.
static av_cold int wmavoice_decode_end(AVCodecContext *ctx)
int lsps
number of LSPs per frame [10 or 16]
main external API structure.
static int wmavoice_decode_packet(AVCodecContext *ctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Packet decoding: a packet is anything that the (ASF) demuxer contains, and we expect that the demuxer...
int block_pitch_nbits
number of bits used to specify the first block's pitch value
@ AV_TX_FLOAT_DST_I
Discrete Sine Transform I.
static int synth_superframe(AVCodecContext *ctx, AVFrame *frame, int *got_frame_ptr)
Synthesize output samples for a single superframe.
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
int frame_cntr
current frame index [0 - 0xFFFE]; is only used for comfort noise in pRNG()
static const float wmavoice_ipol1_coeffs[17 *9]
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
void ff_set_fixed_vector(float *out, const AMRFixed *in, float scale, int size)
Add fixed vector to an array from a sparse representation.
static const float mean_lsf[10]
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Filter the word “frame” indicates either a video frame or a group of audio samples
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.
float avpriv_scalarproduct_float_c(const float *v1, const float *v2, int len)
Return the scalar product of two vectors of floats.
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.
GetBitContext gb
packet bitreader.
#define avpriv_request_sample(...)
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 void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
#define AV_CHANNEL_LAYOUT_MONO
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
static void scale(int *out, const int *in, const int w, const int h, const int shift)
static const int16_t alpha[]
This structure stores compressed data.
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.
#define SFRAME_CACHE_MAXSIZE
maximum cache size for frame data that
static VLCElem frame_type_vlc[132]
Frame type VLC coding.
#define flags(name, subs,...)
AVTXContext * irdft
contexts for FFT-calculation in the
static const float wmavoice_lsp10_intercoeff_a[32][2][10]
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static double a1(void *priv, double x, double y)
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...
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 acb_type
Adaptive codebook type (ACB_TYPE_*)
#define MAX_BLOCKS
maximum number of blocks per frame
void ff_acelp_lspd2lpc(const double *lsp, float *lpc, int lp_half_order)
Reconstruct LPC coefficients from the line spectral pair frequencies.
float postfilter_agc
gain control memory, used in adaptive_gain_control()
static const int8_t pulses[4]
Number of non-zero pulses in the MP-MLQ excitation.
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 * priv_data
Format private data.
WMA Voice decoding context.