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)
53 #define SFRAME_CACHE_MAXSIZE 256
144 int history_nsamples;
151 int denoise_strength;
153 int denoise_tilt_corr;
162 int frame_lsp_bitsize;
164 int sframe_lsp_bitsize;
171 int block_pitch_nbits;
173 int block_pitch_range;
176 int block_delta_pitch_hrange;
180 uint16_t block_conv_table[4];
194 int has_residual_lsps;
242 int aw_first_pulse_off[2];
245 int aw_next_pulse_off_cache;
253 float gain_pred_err[6];
272 float sin[511], cos[511];
274 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)
1054 uint16_t use_mask_mem[9];
1055 uint16_t *use_mask = use_mask_mem + 2;
1064 pulse_start, n, idx, range, aidx, start_off = 0;
1073 if (block_idx == 0) {
1082 pulse_start = s->
aw_n_pulses[block_idx] > 0 ? pulse_off - range / 2 : 0;
1087 memset(&use_mask[-2], 0, 2 *
sizeof(use_mask[0]));
1088 memset( use_mask, -1, 5 *
sizeof(use_mask[0]));
1089 memset(&use_mask[5], 0, 2 *
sizeof(use_mask[0]));
1093 uint16_t *use_mask_ptr = &use_mask[idx >> 4];
1094 int first_sh = 16 - (idx & 15);
1095 *use_mask_ptr++ &= 0xFFFFu << first_sh;
1096 excl_range -= first_sh;
1097 if (excl_range >= 16) {
1098 *use_mask_ptr++ = 0;
1099 *use_mask_ptr &= 0xFFFF >> (excl_range - 16);
1101 *use_mask_ptr &= 0xFFFF >> excl_range;
1106 for (n = 0; n <= aidx; pulse_start++) {
1107 for (idx = pulse_start; idx < 0; idx += fcb->
pitch_lag) ;
1109 if (use_mask[0]) idx = 0x0F;
1110 else if (use_mask[1]) idx = 0x1F;
1111 else if (use_mask[2]) idx = 0x2F;
1112 else if (use_mask[3]) idx = 0x3F;
1113 else if (use_mask[4]) idx = 0x4F;
1115 idx -= av_log2_16bit(use_mask[idx >> 4]);
1117 if (use_mask[idx >> 4] & (0x8000 >> (idx & 15))) {
1118 use_mask[idx >> 4] &= ~(0x8000 >> (idx & 15));
1124 fcb->
x[fcb->
n] = start_off;
1148 int n, v_mask, i_mask, sh, n_pulses;
1162 for (n = n_pulses - 1; n >= 0; n--, val >>= sh) {
1163 fcb->
y[fcb->
n] = (val & v_mask) ? -1.0 : 1.0;
1164 fcb->
x[fcb->
n] = (val & i_mask) * n_pulses + n +
1166 while (fcb->
x[fcb->
n] < 0)
1172 int num2 = (val & 0x1FF) >> 1,
delta, idx;
1174 if (num2 < 1 * 79) {
delta = 1; idx = num2 + 1; }
1175 else if (num2 < 2 * 78) {
delta = 3; idx = num2 + 1 - 1 * 77; }
1176 else if (num2 < 3 * 77) {
delta = 5; idx = num2 + 1 - 2 * 76; }
1177 else {
delta = 7; idx = num2 + 1 - 3 * 75; }
1178 v = (val & 0x200) ? -1.0 : 1.0;
1183 fcb->
x[fcb->
n + 1] = idx;
1184 fcb->
y[fcb->
n + 1] = (val & 1) ? -v : v;
1202 static int pRNG(
int frame_cntr,
int block_num,
int block_size)
1214 static const unsigned int div_tbl[9][2] = {
1215 { 8332, 3 * 715827883
U },
1216 { 4545, 0 * 390451573
U },
1217 { 3124, 11 * 268435456
U },
1218 { 2380, 15 * 204522253
U },
1219 { 1922, 23 * 165191050
U },
1220 { 1612, 23 * 138547333
U },
1221 { 1388, 27 * 119304648
U },
1222 { 1219, 16 * 104755300
U },
1223 { 1086, 39 * 93368855
U }
1225 unsigned int z, y, x =
MUL16(block_num, 1877) + frame_cntr;
1226 if (x >= 0xFFFF) x -= 0xFFFF;
1228 y = x - 9 *
MULH(477218589, x);
1229 z = (uint16_t) (x * div_tbl[y][0] +
UMULH(x, div_tbl[y][1]));
1231 return z % (1000 - block_size);
1239 int block_idx,
int size,
1261 for (n = 0; n <
size; n++)
1270 int block_idx,
int size,
1271 int block_pitch_sh2,
1275 static const float gain_coeff[6] = {
1276 0.8169, -0.06545, 0.1726, 0.0185, -0.0359, 0.0458
1278 float pulses[
MAX_FRAMESIZE / 2], pred_err, acb_gain, fcb_gain;
1279 int n, idx, gain_weight;
1283 memset(pulses, 0,
sizeof(*pulses) * size);
1300 for (n = 0; n <
size; n++)
1312 for (n = 0; n < 5; n++) {
1318 fcb.
x[fcb.
n] = n + 5 * pos1;
1319 fcb.
y[fcb.
n++] = sign;
1320 if (n < frame_desc->dbl_pulses) {
1322 fcb.
x[fcb.
n] = n + 5 * pos2;
1323 fcb.
y[fcb.
n++] = (pos1 < pos2) ? -sign : sign;
1342 for (n = 0; n < gain_weight; n++)
1348 for (n = 0; n <
size; n +=
len) {
1350 int abs_idx = block_idx * size + n;
1353 int pitch = (pitch_sh16 + 0x6FFF) >> 16;
1354 int idx_sh16 = ((pitch << 16) - pitch_sh16) * 8 + 0x58000;
1355 idx = idx_sh16 >> 16;
1358 next_idx_sh16 = (idx_sh16) &~ 0xFFFF;
1360 next_idx_sh16 = (idx_sh16 + 0x10000) &~ 0xFFFF;
1371 int block_pitch = block_pitch_sh2 >> 2;
1372 idx = block_pitch_sh2 & 3;
1379 sizeof(
float) * size);
1384 acb_gain, fcb_gain, size);
1404 int block_idx,
int size,
1405 int block_pitch_sh2,
1406 const double *lsps,
const double *prev_lsps,
1408 float *excitation,
float *synth)
1419 frame_desc, excitation);
1422 fac = (block_idx + 0.5) / frame_desc->
n_blocks;
1423 for (n = 0; n < s->
lsps; n++)
1424 i_lsps[n] = cos(prev_lsps[n] + fac * (lsps[n] - prev_lsps[n]));
1448 const double *lsps,
const double *prev_lsps,
1449 float *excitation,
float *synth)
1452 int n, n_blocks_x2, log_n_blocks_x2, cur_pitch_val;
1460 "Invalid frame type VLC code, skipping\n");
1483 int fac = n * 2 + 1;
1485 pitch[n] = (
MUL16(fac, cur_pitch_val) +
1527 last_block_pitch = av_clip(block_pitch,
1533 if (block_pitch < t1) {
1537 if (block_pitch <
t2) {
1542 if (block_pitch <
t3) {
1549 pitch[n] = bl_pitch_sh2 >> 2;
1554 bl_pitch_sh2 = pitch[n] << 2;
1563 synth_block(s, gb, n, block_nsamples, bl_pitch_sh2,
1565 &excitation[n * block_nsamples],
1566 &synth[n * block_nsamples]);
1575 for (n = 0; n < s->
lsps; n++)
1576 i_lsps[n] = cos(0.5 * (prev_lsps[n] + lsps[n]));
1582 for (n = 0; n < s->
lsps; n++)
1583 i_lsps[n] = cos(lsps[n]);
1585 postfilter(s, &synth[80], &samples[80], 80, lpcs,
1589 memcpy(samples, synth, 160 *
sizeof(synth[0]));
1629 lsps[0] =
FFMAX(lsps[0], 0.0015 *
M_PI);
1630 for (n = 1; n < num; n++)
1631 lsps[n] =
FFMAX(lsps[n], lsps[n - 1] + 0.0125 *
M_PI);
1632 lsps[num - 1] =
FFMIN(lsps[num - 1], 0.9985 *
M_PI);
1636 for (n = 1; n < num; n++) {
1637 if (lsps[n] < lsps[n - 1]) {
1638 for (m = 1; m < num; m++) {
1639 double tmp = lsps[m];
1640 for (l = m - 1; l >= 0; l--) {
1641 if (lsps[l] <= tmp)
break;
1642 lsps[l + 1] = lsps[l];
1664 int n, need_bits, bd_idx;
1686 int aw_idx_is_ext = 0;
1716 need_bits = 2 * !aw_idx_is_ext;
1752 int n, res, n_samples = 480;
1761 s->
lsps *
sizeof(*synth));
1787 if ((n_samples =
get_bits(gb, 12)) > 480) {
1789 "Superframe encodes >480 samples (%d), not allowed\n",
1798 for (n = 0; n < s->
lsps; n++)
1799 prev_lsps[n] = s->
prev_lsps[n] - mean_lsf[n];
1801 if (s->
lsps == 10) {
1806 for (n = 0; n < s->
lsps; n++) {
1807 lsps[0][n] = mean_lsf[n] + (a1[n] - a2[n * 2]);
1808 lsps[1][n] = mean_lsf[n] + (a1[s->
lsps + n] - a2[n * 2 + 1]);
1809 lsps[2][n] += mean_lsf[n];
1811 for (n = 0; n < 3; n++)
1825 for (n = 0; n < 3; n++) {
1829 if (s->
lsps == 10) {
1834 for (m = 0; m < s->
lsps; m++)
1835 lsps[n][m] += mean_lsf[m];
1841 lsps[n], n == 0 ? s->
prev_lsps : lsps[n - 1],
1843 &synth[s->
lsps + n * MAX_FRAMESIZE]))) {
1863 s->
lsps *
sizeof(*synth));
1894 }
while (res == 0x3F);
1919 int rmn_bytes, rmn_bits;
1922 if (rmn_bits < nbits)
1926 rmn_bits &= 7; rmn_bytes >>= 3;
1927 if ((rmn_bits =
FFMIN(rmn_bits, nbits)) > 0)
1930 FFMIN(nbits - rmn_bits, rmn_bytes << 3));
1945 int *got_frame_ptr,
AVPacket *avpkt)
2000 }
else if (*got_frame_ptr) {
2043 for (n = 0; n < s->
lsps; n++)