101 512 , 12,
tab.lsp08, 1, 5, 3, 3,
tab.shape08 , 8, 28, 20, 6, 40
110 512 , 16,
tab.lsp11, 1, 6, 4, 3,
tab.shape11 , 9, 36, 30, 7, 90
119 512 , 16,
tab.lsp11, 1, 6, 4, 3,
tab.shape11 , 9, 36, 30, 7, 90
128 1024, 16,
tab.lsp16, 1, 6, 4, 3,
tab.shape16 , 9, 56, 60, 7, 180
137 1024, 16,
tab.lsp22_1, 1, 6, 4, 3,
tab.shape22_1, 9, 56, 36, 7, 144
146 1024, 16,
tab.lsp22_1, 1, 6, 4, 3,
tab.shape22_1, 9, 56, 36, 7, 144
155 512 , 16,
tab.lsp22_2, 1, 6, 4, 4,
tab.shape22_2, 9, 56, 36, 7, 72
164 2048, 20,
tab.lsp44, 1, 6, 4, 4,
tab.shape44 , 9, 84, 54, 7, 432
173 2048, 20,
tab.lsp44, 1, 6, 4, 4,
tab.shape44 , 9, 84, 54, 7, 432
208 #define PPC_SHAPE_CB_SIZE 64
209 #define PPC_SHAPE_LEN_MAX 60
210 #define SUB_AMP_MAX 4500.0
211 #define MULAW_MU 100.0
213 #define AMP_MAX 13000.0
214 #define SUB_GAIN_BITS 5
215 #define WINDOW_TYPE_BITS 4
217 #define LSP_COEFS_MAX 20
218 #define LSP_SPLIT_MAX 4
219 #define CHANNELS_MAX 2
220 #define SUBBLOCKS_MAX 16
221 #define BARK_N_COEF_MAX 4
247 float two_cos_w = 2.0f*cos_val;
249 for (j = 0; j + 1 < order; j += 2*2) {
251 q *= lsp[j ] - two_cos_w;
252 p *= lsp[j+1] - two_cos_w;
254 q *= lsp[j+2] - two_cos_w;
255 p *= lsp[j+3] - two_cos_w;
258 p *= p * (2.0f - two_cos_w);
259 q *= q * (2.0f + two_cos_w);
261 return 0.5 / (p + q);
273 for (i = 0; i < size_s/2; i++) {
283 float step = (v1 - v2)/(size + 1);
285 for (i = 0; i <
size; i++) {
291 static inline float get_cos(
int idx,
int part,
const float *cos_tab,
int size)
293 return part ? -cos_tab[size - idx - 1] :
313 float *out,
const float *in,
318 const float *cos_tab = tctx->
cos_tabs[ftype];
324 get_cos(i, part, cos_tab, size),
328 for (i = step; i <= size - 2*
step; i +=
step) {
329 if (out[i + step] + out[i - step] > 1.95*out[i] ||
330 out[i + step] >= out[i - step]) {
331 interpolate(out + i - step + 1, out[i], out[i-step], step - 1);
335 get_cos(i-step/2, part, cos_tab, size),
337 interpolate(out + i - step + 1, out[i-step/2], out[i-step ], step/2 - 1);
338 interpolate(out + i - step/2 + 1, out[i ], out[i-step/2], step/2 - 1);
342 interpolate(out + size - 2*step + 1, out[size-step], out[size - 2*step], step - 1);
346 const float *buf,
float *lpc,
352 interpolate(lpc+size/2-step+1, lpc[size/2], lpc[size/2-step], step);
354 memset_float(lpc + size - 2*step + 1, lpc[size - 2*step], 2*step - 1);
364 const int16_t *cb0,
const int16_t *cb1,
int cb_len)
369 for (i = 0; i < tctx->
n_div[ftype]; i++) {
373 const int16_t *tab0, *
tab1;
395 tab0 = cb0 + tmp0*cb_len;
396 tab1 = cb1 + tmp1*cb_len;
398 for (j = 0; j < length; j++)
399 out[tctx->
permut[ftype][pos+j]] = sign0*tab0[j] + sign1*tab1[j];
408 y = av_clipf(y/clip, -1, 1);
409 return clip *
FFSIGN(y) * (exp(log(1+mu) * fabs(y)) - 1) / mu;
443 size =
tabs[b/5].size;
444 rtab =
tabs[b/5].tab;
445 return x - rtab[size*av_log2(2*(x - 1)/size)+(x - 1)%size];
454 float ppc_gain,
float *speech,
int len)
458 const float *shape_end = shape +
len;
462 for (i = 0; i < width/2; i++)
463 speech[i] += ppc_gain * *shape++;
467 for (j = -width/2; j < (width+1)/2; j++)
468 speech[j+center] += ppc_gain * *shape++;
473 for (j = -width/2; j < (width + 1)/2 && shape < shape_end; j++)
474 speech[j+center] += ppc_gain * *shape++;
478 float ppc_gain,
float *speech)
485 int period_range = max_period - min_period;
489 int period = min_period +
493 if (isampf == 22 && ibps == 32) {
513 out[i] = (1./(1<<13)) *
518 float val = (1./(1<<23)) *
522 for (j = 0; j < sub; j++) {
541 float min_dist2 = min_dist * 0.5;
542 for (i = 1; i < order; i++)
543 if (lsp[i] - lsp[i-1] < min_dist) {
544 float avg = (lsp[i] + lsp[i-1]) * 0.5;
546 lsp[i-1] = avg - min_dist2;
547 lsp[i ] = avg + min_dist2;
552 int lpc_hist_idx,
float *lsp,
float *hist)
561 const int8_t funny_rounding[4] = {
570 int chunk_end = ((i + 1)*mtab->
n_lsp + funny_rounding[i])/mtab->
lsp_split;
571 for (; j < chunk_end; j++)
572 lsp[j] = cb [lpc_idx1 * mtab->
n_lsp + j] +
573 cb2[lpc_idx2[i] * mtab->
n_lsp + j];
578 for (i = 0; i < mtab->
n_lsp; i++) {
579 float tmp1 = 1. - cb3[lpc_hist_idx*mtab->
n_lsp + i];
580 float tmp2 = hist[i] * cb3[lpc_hist_idx*mtab->
n_lsp + i];
582 lsp[i] = lsp[i] * tmp1 + tmp2;
597 lsp[i] = 2*cos(lsp[i]);
613 float *in,
float *prev,
int ch)
627 static const uint8_t wtype_to_wsize[] = {0, 0, 2, 2, 2, 1, 0, 1, 1};
628 int types_sizes[] = {
634 wsize = types_sizes[wtype_to_wsize[wtype]];
636 prev_buf = prev + (size - bsize)/2;
638 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
639 int sub_wtype = ftype ==
FT_MEDIUM ? 8 : wtype;
641 if (!j && wtype == 4)
643 else if (j == mtab->
fmode[ftype].
sub-1 && wtype == 7)
646 wsize = types_sizes[wtype_to_wsize[sub_wtype]];
648 mdct->
imdct_half(mdct, buf1 + bsize*j, in + bsize*j);
651 prev_buf + (bsize-wsize)/2,
657 memcpy(out2, buf1 + bsize*j + wsize/2, (bsize - wsize/2)*
sizeof(
float));
659 out2 += ftype ==
FT_MEDIUM ? (bsize-wsize)/2 : bsize - wsize;
661 prev_buf = buf1 + bsize*j + bsize/2;
678 prev_buf + 2*i*mtab->
size,
686 size1 = mtab->
size - size2;
689 &prev_buf[2*mtab->
size],
698 memcpy(out, prev_buf, size1 *
sizeof(*out));
702 memcpy(out, tctx->
curr_frame, size2 *
sizeof(*out));
708 int ch,
float *out,
float gain,
enum FrameType ftype)
712 float *hist = tctx->
bark_hist[ftype][ch];
713 float val = ((
const float []) {0.4, 0.35, 0.28})[ftype];
718 for (i = 0; i < fw_cb_len; i++)
719 for (j = 0; j < bark_n_coef; j++, idx++) {
721 mtab->
fmode[ftype].
bark_cb[fw_cb_len*in[j] + i] * (1./4096);
722 float st = use_hist ?
723 (1. - val) * tmp2 + val*hist[idx] + 1. : tmp2 + 1.;
726 if (st < -1.) st = 1.;
740 int block_size = mtab->
size / sub;
756 for (i = 0; i < channels; i++)
757 for (j = 0; j < sub; j++)
762 for (i = 0; i < channels; i++)
763 for (j = 0; j < sub; j++)
768 for (i = 0; i < channels; i++) {
783 for (i = 0; i < channels; i++) {
784 float *chunk = out + mtab->
size * i;
787 for (j = 0; j < sub; j++) {
789 tctx->
tmp_buf, gain[sub*i+j], ftype);
797 float pgain_step = 25000. / ((1 << mtab->
pgain_bit) - 1);
807 decode_lsp(tctx, lpc_idx1[i], lpc_idx2[i], lpc_hist_idx[i], lsp,
812 for (j = 0; j < mtab->
fmode[ftype].
sub; j++) {
820 int *got_frame_ptr,
AVPacket *avpkt)
822 const uint8_t *buf = avpkt->
data;
823 int buf_size = avpkt->
size;
829 int window_type, ret;
830 static const enum FrameType wtype_to_ftype_table[] = {
837 "Frame too small (%d bytes). Truncated file?\n", buf_size);
855 if (window_type > 8) {
860 ftype = wtype_to_ftype_table[window_type];
890 float norm = channels == 1 ? 2. : 1.;
892 for (i = 0; i < 3; i++) {
895 -sqrt(norm/bsize) / (1<<15))))
912 for (i = 0; i < 3; i++) {
914 double freq = 2*
M_PI/m;
916 (m / 4) *
sizeof(*tctx->
cos_tabs[i]), alloc_fail);
918 for (j = 0; j <= m/8; j++)
919 tctx->
cos_tabs[i][j] = cos((2*j + 1)*freq);
920 for (j = 1; j < m/8; j++)
942 const uint8_t line_len[2],
int length_div,
948 for (i = 0; i < line_len[0]; i++) {
951 if (num_blocks == 1 ||
952 (ftype ==
FT_LONG && num_vect % num_blocks) ||
953 (ftype !=
FT_LONG && num_vect & 1 ) ||
961 for (j = 0; j < num_vect && (j+num_vect*i < block_size*num_blocks); j++)
962 tab[i*num_vect+j] = i*num_vect + (j + shift) % num_vect;
982 const uint8_t line_len[2],
int length_div)
986 for (i = 0; i < num_vect; i++)
987 for (j = 0; j < line_len[i >= length_div]; j++)
988 out[cont++] = in[j*num_vect + i];
991 static void linear_perm(int16_t *out, int16_t *in,
int n_blocks,
int size)
993 int block_size = size/n_blocks;
996 for (i = 0; i <
size; i++)
997 out[i] = block_size * (in[i] % n_blocks) + in[i] / n_blocks;
1005 int16_t *tmp_perm = (int16_t *) tctx->
tmp_buf;
1016 block_size, tctx->
length[ftype],
1039 int bsize_no_main_cb[3];
1044 for (i = 0; i < 3; i++)
1046 bse_bits[i] = n_ch *
1049 bsize_no_main_cb[2] = bse_bits[2] + lsp_bits_per_block + ppc_bits +
1052 for (i = 0; i < 2; i++)
1053 bsize_no_main_cb[i] =
1058 for (i = 0; i < 4; i++) {
1061 int rounded_up, rounded_down, num_rounded_down, num_rounded_up;
1066 bit_size = total_fr_bits - bsize_no_main_cb[i];
1067 vect_size = n_ch * mtab->
size;
1070 tctx->
n_div[i] = (bit_size + 13) / 14;
1072 rounded_up = (bit_size + tctx->
n_div[i] - 1)/tctx->
n_div[i];
1073 rounded_down = (bit_size )/tctx->
n_div[i];
1074 num_rounded_down = rounded_up * tctx->
n_div[i] - bit_size;
1075 num_rounded_up = tctx->
n_div[i] - num_rounded_down;
1082 rounded_up = (vect_size + tctx->
n_div[i] - 1)/tctx->
n_div[i];
1083 rounded_down = (vect_size )/tctx->
n_div[i];
1084 num_rounded_down = rounded_up * tctx->
n_div[i] - vect_size;
1085 num_rounded_up = tctx->
n_div[i] - num_rounded_down;
1086 tctx->
length[i][0] = rounded_up;
1087 tctx->
length[i][1] = rounded_down;
1100 for (i = 0; i < 3; i++) {
1120 tctx->
avctx = avctx;
1134 default: avctx->
sample_rate = isampf * 1000;
break;
1143 if (ibps < 8 || ibps > 48) {
1148 switch ((isampf << 8) + ibps) {
1159 av_log(avctx,
AV_LOG_ERROR,
"This version does not support %d kHz - %d kbit/s/ch mode.\n", isampf, isampf);