28 #define UNCHECKED_BITSTREAM_READER 1
47 #define MAX_LSPS_ALIGN16 16
50 #define MAX_FRAMESIZE 160
51 #define MAX_SIGNAL_HISTORY 416
52 #define MAX_SFRAMESIZE (MAX_FRAMESIZE * MAX_FRAMES)
54 #define SFRAME_CACHE_MAXSIZE 256
143 int spillover_bitsize;
146 int history_nsamples;
152 int denoise_strength;
154 int denoise_tilt_corr;
163 int frame_lsp_bitsize;
165 int sframe_lsp_bitsize;
172 int block_pitch_nbits;
175 int block_delta_pitch_nbits;
179 int block_delta_pitch_hrange;
181 uint16_t block_conv_table[4];
197 int has_residual_lsps;
209 int sframe_cache_size;
244 int aw_first_pulse_off[2];
246 int aw_next_pulse_off_cache;
254 float gain_pred_err[6];
273 float sin[511], cos[511];
275 float postfilter_agc;
306 static const uint8_t
bits[] = {
309 10, 10, 10, 12, 12, 12,
312 static const uint16_t codes[] = {
313 0x0000, 0x0001, 0x0002,
314 0x000c, 0x000d, 0x000e,
315 0x003c, 0x003d, 0x003e,
316 0x00fc, 0x00fd, 0x00fe,
317 0x03fc, 0x03fd, 0x03fe,
318 0x0ffc, 0x0ffd, 0x0ffe,
319 0x3ffc, 0x3ffd, 0x3ffe, 0x3fff
323 memset(vbm_tree, 0xff,
sizeof(vbm_tree[0]) * 25);
324 memset(cntr, 0,
sizeof(cntr));
325 for (n = 0; n < 17; n++) {
329 vbm_tree[res * 3 + cntr[res]++] = n;
332 bits, 1, 1, codes, 2, 2, 132);
341 int n,
flags, pitch_range, lsp16_flag;
354 "Invalid extradata size %d (should be 46)\n",
368 memcpy(&s->
sin[255], s->
cos, 256 *
sizeof(s->
cos[0]));
369 for (n = 0; n < 255; n++) {
370 s->
sin[n] = -s->
sin[510 - n];
371 s->
cos[510 - n] = s->
cos[n];
377 "Invalid denoise filter strength %d (max=11)\n",
385 lsp16_flag = flags & 0x1000;
395 for (n = 0; n < s->
lsps; n++)
407 if (pitch_range <= 0) {
417 int min_sr = ((((1 << 8) - 50) * 400) + 0xFF) >> 8,
421 "Unsupported samplerate %d (min=%d, max=%d)\n",
472 const float *speech_synth,
473 int size,
float alpha,
float *gain_mem)
476 float speech_energy = 0.0, postfilter_energy = 0.0, gain_scale_factor;
477 float mem = *gain_mem;
479 for (i = 0; i <
size; i++) {
480 speech_energy += fabsf(speech_synth[i]);
481 postfilter_energy += fabsf(in[i]);
483 gain_scale_factor = (1.0 - alpha) * speech_energy / postfilter_energy;
485 for (i = 0; i <
size; i++) {
486 mem = alpha * mem + gain_scale_factor;
487 out[i] = in[i] * mem;
512 const float *in,
float *out,
int size)
515 float optimal_gain = 0, dot;
523 if (dot > optimal_gain) {
527 }
while (--ptr >= end);
529 if (optimal_gain <= 0)
535 if (optimal_gain <= dot) {
536 dot = dot / (dot + 0.6 * optimal_gain);
541 for (n = 0; n <
size; n++)
542 out[n] = best_hist_ptr[n] + dot * (in[n] - best_hist_ptr[n]);
571 int fcb_type,
float *
coeffs,
int remainder)
574 float irange, angle_mul, gain_mul, range,
sq;
579 #define log_range(var, assign) do { \
580 float tmp = log10f(assign); var = tmp; \
581 max = FFMAX(max, tmp); min = FFMIN(min, tmp); \
583 log_range(last_coeff, lpcs[1] * lpcs[1]);
584 for (n = 1; n < 64; n++)
585 log_range(lpcs[n], lpcs[n * 2] * lpcs[n * 2] +
586 lpcs[n * 2 + 1] * lpcs[n * 2 + 1]);
597 irange = 64.0 / range;
601 for (n = 0; n <= 64; n++) {
604 idx =
FFMAX(0,
lrint((max - lpcs[n]) * irange) - 1);
606 lpcs[n] = angle_mul * pwr;
609 idx = (pwr * gain_mul - 0.0295) * 70.570526123;
612 powf(1.0331663, idx - 127);
625 idx = 255 + av_clip(lpcs[64], -255, 255);
626 coeffs[0] = coeffs[0] * s->
cos[idx];
627 idx = 255 + av_clip(lpcs[64] - 2 * lpcs[63], -255, 255);
628 last_coeff = coeffs[64] * s->
cos[idx];
630 idx = 255 + av_clip(-lpcs[64] - 2 * lpcs[n - 1], -255, 255);
631 coeffs[n * 2 + 1] = coeffs[n] * s->
sin[idx];
632 coeffs[n * 2] = coeffs[n] * s->
cos[idx];
636 idx = 255 + av_clip( lpcs[64] - 2 * lpcs[n - 1], -255, 255);
637 coeffs[n * 2 + 1] = coeffs[n] * s->
sin[idx];
638 coeffs[n * 2] = coeffs[n] * s->
cos[idx];
646 memset(&coeffs[remainder], 0,
sizeof(coeffs[0]) * (128 - remainder));
650 coeffs[remainder - 1] = 0;
655 sq = (1.0 / 64.0) * sqrtf(1 /
ff_dot_productf(coeffs, coeffs, remainder));
656 for (n = 0; n < remainder; n++)
687 float *synth_pf,
int size,
690 int remainder, lim, n;
696 tilted_lpcs[0] = 1.0;
697 memcpy(&tilted_lpcs[1], lpcs,
sizeof(lpcs[0]) * s->
lsps);
698 memset(&tilted_lpcs[s->
lsps + 1], 0,
699 sizeof(tilted_lpcs[0]) * (128 - s->
lsps - 1));
701 tilted_lpcs, s->
lsps + 2);
707 remainder =
FFMIN(127 - size, size - 1);
712 memset(&synth_pf[size], 0,
sizeof(synth_pf[0]) * (128 - size));
717 for (n = 1; n < 64; n++) {
718 float v1 = synth_pf[n * 2], v2 = synth_pf[n * 2 + 1];
719 synth_pf[n * 2] = v1 *
coeffs[n * 2] - v2 *
coeffs[n * 2 + 1];
720 synth_pf[n * 2 + 1] = v2 * coeffs[n * 2] + v1 * coeffs[n * 2 + 1];
728 for (n = 0; n < lim; n++)
738 for (n = 0; n < lim; n++)
740 if (lim < remainder) {
770 const float *lpcs,
float *zero_exc_pf,
771 int fcb_type,
int pitch)
775 *synth_filter_in = zero_exc_pf;
784 synth_filter_in = synth_filter_in_buf;
788 synth_filter_in, size, s->
lsps);
789 memcpy(&synth_pf[-s->
lsps], &synth_pf[size - s->
lsps],
790 sizeof(synth_pf[0]) * s->
lsps);
802 (
const float[2]) { -1.99997, 1.0 },
803 (
const float[2]) { -1.9330735188, 0.93589198496 },
823 const uint16_t *values,
824 const uint16_t *
sizes,
825 int n_stages,
const uint8_t *table,
827 const double *base_q)
831 memset(lsps, 0, num *
sizeof(*lsps));
832 for (n = 0; n < n_stages; n++) {
833 const uint8_t *t_off = &table[values[n] * num];
834 double base = base_q[n], mul = mul_q[n];
836 for (m = 0; m < num; m++)
837 lsps[m] += base + mul * t_off[m];
839 table += sizes[n] * num;
856 static const uint16_t vec_sizes[4] = { 256, 64, 32, 32 };
857 static const double mul_lsf[4] = {
858 5.2187144800e-3, 1.4626986422e-3,
859 9.6179549166e-4, 1.1325736225e-3
861 static const double base_lsf[4] = {
862 M_PI * -2.15522e-1,
M_PI * -6.1646e-2,
863 M_PI * -3.3486e-2,
M_PI * -5.7408e-2
881 double *i_lsps,
const double *old,
882 double *
a1,
double *
a2,
int q_mode)
884 static const uint16_t vec_sizes[3] = { 128, 64, 64 };
885 static const double mul_lsf[3] = {
886 2.5807601174e-3, 1.2354460219e-3, 1.1763821673e-3
888 static const double base_lsf[3] = {
889 M_PI * -1.07448e-1,
M_PI * -5.2706e-2,
M_PI * -5.1634e-2
891 const float (*ipol_tab)[2][10] = q_mode ?
893 uint16_t interpol,
v[3];
903 for (n = 0; n < 10; n++) {
904 double delta = old[n] - i_lsps[n];
905 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
906 a1[10 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
918 static const uint16_t vec_sizes[5] = { 256, 64, 128, 64, 128 };
919 static const double mul_lsf[5] = {
920 3.3439586280e-3, 6.9908173703e-4,
921 3.3216608306e-3, 1.0334960326e-3,
924 static const double base_lsf[5] = {
925 M_PI * -1.27576e-1,
M_PI * -2.4292e-2,
926 M_PI * -1.28094e-1,
M_PI * -3.2128e-2,
950 double *i_lsps,
const double *old,
951 double *
a1,
double *
a2,
int q_mode)
953 static const uint16_t vec_sizes[3] = { 128, 128, 128 };
954 static const double mul_lsf[3] = {
955 1.2232979501e-3, 1.4062241527e-3, 1.6114744851e-3
957 static const double base_lsf[3] = {
960 const float (*ipol_tab)[2][16] = q_mode ?
962 uint16_t interpol,
v[3];
972 for (n = 0; n < 16; n++) {
973 double delta = old[n] - i_lsps[n];
974 a1[n] = ipol_tab[interpol][0][n] * delta + i_lsps[n];
975 a1[16 + n] = ipol_tab[interpol][1][n] * delta + i_lsps[n];
1002 static const int16_t start_offset[94] = {
1003 -11, -9, -7, -5, -3, -1, 1, 3, 5, 7, 9, 11,
1004 13, 15, 18, 17, 19, 20, 21, 22, 23, 24, 25, 26,
1005 27, 28, 29, 30, 31, 32, 33, 35, 37, 39, 41, 43,
1006 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
1007 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91,
1008 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115,
1009 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139,
1010 141, 143, 145, 147, 149, 151, 153, 155, 157, 159
1016 if ((bits =
get_bits(gb, 6)) >= 54) {
1018 bits += (bits - 54) * 3 +
get_bits(gb, 2);
1024 for (offset = start_offset[bits]; offset < 0; offset += pitch[0]) ;
1037 if (start_offset[bits] < 0)
1053 uint16_t use_mask_mem[9];
1054 uint16_t *use_mask = use_mask_mem + 2;
1063 pulse_start, n, idx, range, aidx, start_off = 0;
1072 if (block_idx == 0) {
1081 pulse_start = s->
aw_n_pulses[block_idx] > 0 ? pulse_off - range / 2 : 0;
1086 memset(&use_mask[-2], 0, 2 *
sizeof(use_mask[0]));
1087 memset( use_mask, -1, 5 *
sizeof(use_mask[0]));
1088 memset(&use_mask[5], 0, 2 *
sizeof(use_mask[0]));
1092 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
1093 int first_sh = 16 - (idx & 15);
1094 *use_mask_ptr++ &= 0xFFFFu << first_sh;
1095 excl_range -= first_sh;
1096 if (excl_range >= 16) {
1097 *use_mask_ptr++ = 0;
1098 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
1100 *use_mask_ptr &= 0xFFFF >> excl_range;
1105 for (n = 0; n <= aidx; pulse_start++) {
1106 for (idx = pulse_start; idx < 0; idx += fcb->
pitch_lag) ;
1108 if (use_mask[0]) idx = 0x0F;
1109 else if (use_mask[1]) idx = 0x1F;
1110 else if (use_mask[2]) idx = 0x2F;
1111 else if (use_mask[3]) idx = 0x3F;
1112 else if (use_mask[4]) idx = 0x4F;
1114 idx -= av_log2_16bit(use_mask[idx >> 4]);
1116 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
1117 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
1123 fcb->
x[fcb->
n] = start_off;
1146 int n, v_mask, i_mask, sh, n_pulses;
1160 for (n = n_pulses - 1; n >= 0; n--, val >>= sh) {
1161 fcb->
y[fcb->
n] = (val & v_mask) ? -1.0 : 1.0;
1162 fcb->
x[fcb->
n] = (val & i_mask) * n_pulses + n +
1164 while (fcb->
x[fcb->
n] < 0)
1170 int num2 = (val & 0x1FF) >> 1,
delta, idx;
1172 if (num2 < 1 * 79) {
delta = 1; idx = num2 + 1; }
1173 else if (num2 < 2 * 78) {
delta = 3; idx = num2 + 1 - 1 * 77; }
1174 else if (num2 < 3 * 77) {
delta = 5; idx = num2 + 1 - 2 * 76; }
1175 else {
delta = 7; idx = num2 + 1 - 3 * 75; }
1176 v = (val & 0x200) ? -1.0 : 1.0;
1181 fcb->
x[fcb->
n + 1] = idx;
1182 fcb->
y[fcb->
n + 1] = (val & 1) ? -v : v;
1200 static int pRNG(
int frame_cntr,
int block_num,
int block_size)
1212 static const unsigned int div_tbl[9][2] = {
1213 { 8332, 3 * 715827883
U },
1214 { 4545, 0 * 390451573
U },
1215 { 3124, 11 * 268435456
U },
1216 { 2380, 15 * 204522253
U },
1217 { 1922, 23 * 165191050
U },
1218 { 1612, 23 * 138547333
U },
1219 { 1388, 27 * 119304648
U },
1220 { 1219, 16 * 104755300
U },
1221 { 1086, 39 * 93368855
U }
1223 unsigned int z, y, x =
MUL16(block_num, 1877) + frame_cntr;
1224 if (x >= 0xFFFF) x -= 0xFFFF;
1226 y = x - 9 *
MULH(477218589, x);
1227 z = (uint16_t) (x * div_tbl[y][0] +
UMULH(x, div_tbl[y][1]));
1229 return z % (1000 - block_size);
1237 int block_idx,
int size,
1259 for (n = 0; n <
size; n++)
1268 int block_idx,
int size,
1269 int block_pitch_sh2,
1273 static const float gain_coeff[6] = {
1274 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
1276 float pulses[
MAX_FRAMESIZE / 2], pred_err, acb_gain, fcb_gain;
1277 int n, idx, gain_weight;
1281 memset(pulses, 0,
sizeof(*pulses) * size);
1299 for (n = 0; n < 5; n++) {
1305 fcb.
x[fcb.
n] = n + 5 * pos1;
1306 fcb.
y[fcb.
n++] = sign;
1307 if (n < frame_desc->dbl_pulses) {
1309 fcb.
x[fcb.
n] = n + 5 * pos2;
1310 fcb.
y[fcb.
n++] = (pos1 < pos2) ? -sign : sign;
1329 for (n = 0; n < gain_weight; n++)
1335 for (n = 0; n <
size; n +=
len) {
1337 int abs_idx = block_idx * size + n;
1340 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
1341 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
1342 idx = idx_sh16 >> 16;
1345 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
1347 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
1358 int block_pitch = block_pitch_sh2 >> 2;
1359 idx = block_pitch_sh2 & 3;
1366 sizeof(
float) * size);
1371 acb_gain, fcb_gain, size);
1391 int block_idx,
int size,
1392 int block_pitch_sh2,
1393 const double *lsps,
const double *prev_lsps,
1395 float *excitation,
float *synth)
1406 frame_desc, excitation);
1409 fac = (block_idx + 0.5) / frame_desc->
n_blocks;
1410 for (n = 0; n < s->
lsps; n++)
1411 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
1435 const double *lsps,
const double *prev_lsps,
1436 float *excitation,
float *synth)
1439 int n, n_blocks_x2, log_n_blocks_x2, cur_pitch_val;
1447 "Invalid frame type VLC code, skipping\n");
1470 int fac = n * 2 + 1;
1472 pitch[n] = (
MUL16(fac, cur_pitch_val) +
1514 last_block_pitch = av_clip(block_pitch,
1520 if (block_pitch < t1) {
1524 if (block_pitch <
t2) {
1529 if (block_pitch <
t3) {
1536 pitch[n] = bl_pitch_sh2 >> 2;
1541 bl_pitch_sh2 = pitch[n] << 2;
1550 synth_block(s, gb, n, block_nsamples, bl_pitch_sh2,
1552 &excitation[n * block_nsamples],
1553 &synth[n * block_nsamples]);
1562 for (n = 0; n < s->
lsps; n++)
1563 i_lsps[n] = cos(0.5 * (prev_lsps[n] + lsps[n]));
1569 for (n = 0; n < s->
lsps; n++)
1570 i_lsps[n] = cos(lsps[n]);
1572 postfilter(s, &synth[80], &samples[80], 80, lpcs,
1576 memcpy(samples, synth, 160 *
sizeof(synth[0]));
1616 lsps[0] =
FFMAX(lsps[0], 0.0015 *
M_PI);
1617 for (n = 1; n < num; n++)
1618 lsps[n] =
FFMAX(lsps[n], lsps[n - 1] + 0.0125 *
M_PI);
1619 lsps[num - 1] =
FFMIN(lsps[num - 1], 0.9985 *
M_PI);
1623 for (n = 1; n < num; n++) {
1624 if (lsps[n] < lsps[n - 1]) {
1625 for (m = 1; m < num; m++) {
1626 double tmp = lsps[m];
1627 for (l = m - 1; l >= 0; l--) {
1628 if (lsps[l] <= tmp)
break;
1629 lsps[l + 1] = lsps[l];
1651 int n, need_bits, bd_idx;
1673 int aw_idx_is_ext = 0;
1703 need_bits = 2 * !aw_idx_is_ext;
1739 int n, res, n_samples = 480;
1748 s->
lsps *
sizeof(*synth));
1774 if ((n_samples =
get_bits(gb, 12)) > 480) {
1776 "Superframe encodes >480 samples (%d), not allowed\n",
1785 for (n = 0; n < s->
lsps; n++)
1786 prev_lsps[n] = s->
prev_lsps[n] - mean_lsf[n];
1788 if (s->
lsps == 10) {
1793 for (n = 0; n < s->
lsps; n++) {
1794 lsps[0][n] = mean_lsf[n] + (a1[n] - a2[n * 2]);
1795 lsps[1][n] = mean_lsf[n] + (a1[s->
lsps + n] - a2[n * 2 + 1]);
1796 lsps[2][n] += mean_lsf[n];
1798 for (n = 0; n < 3; n++)
1812 for (n = 0; n < 3; n++) {
1816 if (s->
lsps == 10) {
1821 for (m = 0; m < s->
lsps; m++)
1822 lsps[n][m] += mean_lsf[m];
1828 lsps[n], n == 0 ? s->
prev_lsps : lsps[n - 1],
1830 &synth[s->
lsps + n * MAX_FRAMESIZE]))) {
1850 s->
lsps *
sizeof(*synth));
1881 }
while (res == 0x3F);
1906 int rmn_bytes, rmn_bits;
1909 if (rmn_bits < nbits)
1913 rmn_bits &= 7; rmn_bytes >>= 3;
1914 if ((rmn_bits =
FFMIN(rmn_bits, nbits)) > 0)
1917 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
1932 int *got_frame_ptr,
AVPacket *avpkt)
1987 }
else if (*got_frame_ptr) {
2030 for (n = 0; n < s->
lsps; n++)