2 * SIPR decoder for the 16k mode
4 * Copyright (c) 2008 Vladimir Voroshilov
5 * Copyright (c) 2009 Vitor Sessak
7 * This file is part of FFmpeg.
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/float_dsp.h"
30 #include "libavutil/mathematics.h"
32 #include "acelp_vectors.h"
33 #include "acelp_pitch_delay.h"
34 #include "acelp_filters.h"
35 #include "celp_filters.h"
37 #include "sipr16kdata.h"
40 * Convert an lsf vector into an lsp vector.
42 * @param lsf input lsf vector
43 * @param lsp output lsp vector
45 static void lsf2lsp(const float *lsf
, double *lsp
)
49 for (i
= 0; i
< LP_FILTER_ORDER_16k
; i
++)
50 lsp
[i
] = cosf(lsf
[i
]);
53 static void dequant(float *out
, const int *idx
, const float * const cbs
[])
57 for (i
= 0; i
< 4; i
++)
58 memcpy(out
+ 3*i
, cbs
[i
] + 3*idx
[i
], 3*sizeof(float));
60 memcpy(out
+ 12, cbs
[4] + 4*idx
[4], 4*sizeof(float));
63 static void lsf_decode_fp_16k(float* lsf_history
, float* isp_new
,
64 const int* parm
, int ma_pred
)
67 float isp_q
[LP_FILTER_ORDER_16k
];
69 dequant(isp_q
, parm
, lsf_codebooks_16k
);
71 for (i
= 0; i
< LP_FILTER_ORDER_16k
; i
++) {
72 isp_new
[i
] = (1 - qu
[ma_pred
]) * isp_q
[i
]
73 + qu
[ma_pred
] * lsf_history
[i
]
77 memcpy(lsf_history
, isp_q
, LP_FILTER_ORDER_16k
* sizeof(float));
80 static int dec_delay3_1st(int index
)
85 return 3 * index
- 690;
88 static int dec_delay3_2nd(int index
, int pit_min
, int pit_max
,
92 int pitch_delay_min
= av_clip(pitch_lag_prev
- 10,
93 pit_min
, pit_max
- 19);
94 return 3 * pitch_delay_min
+ index
- 2;
96 return 3 * pitch_lag_prev
;
99 static void postfilter(float *out_data
, float* synth
, float* iir_mem
,
100 float* filt_mem
[2], float* mem_preemph
)
102 float buf
[30 + LP_FILTER_ORDER_16k
];
103 float *tmpbuf
= buf
+ LP_FILTER_ORDER_16k
;
107 for (i
= 0; i
< LP_FILTER_ORDER_16k
; i
++)
108 filt_mem
[0][i
] = iir_mem
[i
] * ff_pow_0_5
[i
];
110 memcpy(tmpbuf
- LP_FILTER_ORDER_16k
, mem_preemph
,
111 LP_FILTER_ORDER_16k
*sizeof(*buf
));
113 ff_celp_lp_synthesis_filterf(tmpbuf
, filt_mem
[1], synth
, 30,
114 LP_FILTER_ORDER_16k
);
116 memcpy(synth
- LP_FILTER_ORDER_16k
, mem_preemph
,
117 LP_FILTER_ORDER_16k
* sizeof(*synth
));
119 ff_celp_lp_synthesis_filterf(synth
, filt_mem
[0], synth
, 30,
120 LP_FILTER_ORDER_16k
);
122 memcpy(out_data
+ 30 - LP_FILTER_ORDER_16k
,
123 synth
+ 30 - LP_FILTER_ORDER_16k
,
124 LP_FILTER_ORDER_16k
* sizeof(*synth
));
126 ff_celp_lp_synthesis_filterf(out_data
+ 30, filt_mem
[0],
127 synth
+ 30, 2 * L_SUBFR_16k
- 30,
128 LP_FILTER_ORDER_16k
);
131 memcpy(mem_preemph
, out_data
+ 2*L_SUBFR_16k
- LP_FILTER_ORDER_16k
,
132 LP_FILTER_ORDER_16k
* sizeof(*synth
));
134 FFSWAP(float *, filt_mem
[0], filt_mem
[1]);
135 for (i
= 0, s
= 0; i
< 30; i
++, s
+= 1.0/30)
136 out_data
[i
] = tmpbuf
[i
] + s
* (synth
[i
] - tmpbuf
[i
]);
140 * Floating point version of ff_acelp_lp_decode().
142 static void acelp_lp_decodef(float *lp_1st
, float *lp_2nd
,
143 const double *lsp_2nd
, const double *lsp_prev
)
145 double lsp_1st
[LP_FILTER_ORDER_16k
];
148 /* LSP values for first subframe (3.2.5 of G.729, Equation 24) */
149 for (i
= 0; i
< LP_FILTER_ORDER_16k
; i
++)
150 lsp_1st
[i
] = (lsp_2nd
[i
] + lsp_prev
[i
]) * 0.5;
152 ff_acelp_lspd2lpc(lsp_1st
, lp_1st
, LP_FILTER_ORDER_16k
>> 1);
154 /* LSP values for second subframe (3.2.5 of G.729) */
155 ff_acelp_lspd2lpc(lsp_2nd
, lp_2nd
, LP_FILTER_ORDER_16k
>> 1);
159 * Floating point version of ff_acelp_decode_gain_code().
161 static float acelp_decode_gain_codef(float gain_corr_factor
, const float *fc_v
,
162 float mr_energy
, const float *quant_energy
,
163 const float *ma_prediction_coeff
,
164 int subframe_size
, int ma_pred_order
)
166 mr_energy
+= avpriv_scalarproduct_float_c(quant_energy
, ma_prediction_coeff
,
169 mr_energy
= gain_corr_factor
* exp(M_LN10
/ 20. * mr_energy
) /
170 sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v
, fc_v
, subframe_size
)));
174 #define DIVIDE_BY_3(x) ((x) * 10923 >> 15)
176 void ff_sipr_decode_frame_16k(SiprContext
*ctx
, SiprParameters
*params
,
179 int frame_size
= SUBFRAME_COUNT_16k
* L_SUBFR_16k
;
180 float *synth
= ctx
->synth_buf
+ LP_FILTER_ORDER_16k
;
181 float lsf_new
[LP_FILTER_ORDER_16k
];
182 double lsp_new
[LP_FILTER_ORDER_16k
];
183 float Az
[2][LP_FILTER_ORDER_16k
];
184 float fixed_vector
[L_SUBFR_16k
];
185 float pitch_fac
, gain_code
;
190 float *excitation
= ctx
->excitation
+ 292;
192 lsf_decode_fp_16k(ctx
->lsf_history
, lsf_new
, params
->vq_indexes
,
193 params
->ma_pred_switch
);
195 ff_set_min_dist_lsf(lsf_new
, LSFQ_DIFF_MIN
/ 2, LP_FILTER_ORDER_16k
);
197 lsf2lsp(lsf_new
, lsp_new
);
199 acelp_lp_decodef(Az
[0], Az
[1], lsp_new
, ctx
->lsp_history_16k
);
201 memcpy(ctx
->lsp_history_16k
, lsp_new
, LP_FILTER_ORDER_16k
* sizeof(double));
203 memcpy(synth
- LP_FILTER_ORDER_16k
, ctx
->synth
,
204 LP_FILTER_ORDER_16k
* sizeof(*synth
));
206 for (i
= 0; i
< SUBFRAME_COUNT_16k
; i
++) {
207 int i_subfr
= i
* L_SUBFR_16k
;
209 float gain_corr_factor
;
211 int pitch_delay_frac
;
214 pitch_delay_3x
= dec_delay3_1st(params
->pitch_delay
[i
]);
216 pitch_delay_3x
= dec_delay3_2nd(params
->pitch_delay
[i
],
217 PITCH_MIN
, PITCH_MAX
,
218 ctx
->pitch_lag_prev
);
220 pitch_fac
= gain_pitch_cb_16k
[params
->gp_index
[i
]];
221 f
.pitch_fac
= FFMIN(pitch_fac
, 1.0);
222 f
.pitch_lag
= DIVIDE_BY_3(pitch_delay_3x
+1);
223 ctx
->pitch_lag_prev
= f
.pitch_lag
;
225 pitch_delay_int
= DIVIDE_BY_3(pitch_delay_3x
+ 2);
226 pitch_delay_frac
= pitch_delay_3x
+ 2 - 3*pitch_delay_int
;
228 ff_acelp_interpolatef(&excitation
[i_subfr
],
229 &excitation
[i_subfr
] - pitch_delay_int
+ 1,
230 sinc_win
, 3, pitch_delay_frac
+ 1,
231 LP_FILTER_ORDER
, L_SUBFR_16k
);
234 memset(fixed_vector
, 0, sizeof(fixed_vector
));
236 ff_decode_10_pulses_35bits(params
->fc_indexes
[i
], &f
,
237 ff_fc_4pulses_8bits_tracks_13
, 5, 4);
239 ff_set_fixed_vector(fixed_vector
, &f
, 1.0, L_SUBFR_16k
);
241 gain_corr_factor
= gain_cb_16k
[params
->gc_index
[i
]];
242 gain_code
= gain_corr_factor
*
243 acelp_decode_gain_codef(sqrt(L_SUBFR_16k
), fixed_vector
,
244 19.0 - 15.0/(0.05*M_LN10
/M_LN2
),
245 pred_16k
, ctx
->energy_history
,
248 ctx
->energy_history
[1] = ctx
->energy_history
[0];
249 ctx
->energy_history
[0] = 20.0 * log10f(gain_corr_factor
);
251 ff_weighted_vector_sumf(&excitation
[i_subfr
], &excitation
[i_subfr
],
252 fixed_vector
, pitch_fac
,
253 gain_code
, L_SUBFR_16k
);
255 ff_celp_lp_synthesis_filterf(synth
+ i_subfr
, Az
[i
],
256 &excitation
[i_subfr
], L_SUBFR_16k
,
257 LP_FILTER_ORDER_16k
);
260 memcpy(ctx
->synth
, synth
+ frame_size
- LP_FILTER_ORDER_16k
,
261 LP_FILTER_ORDER_16k
* sizeof(*synth
));
263 memmove(ctx
->excitation
, ctx
->excitation
+ 2 * L_SUBFR_16k
,
264 (L_INTERPOL
+PITCH_MAX
) * sizeof(float));
266 postfilter(out_data
, synth
, ctx
->iir_mem
, ctx
->filt_mem
, ctx
->mem_preemph
);
268 memcpy(ctx
->iir_mem
, Az
[1], LP_FILTER_ORDER_16k
* sizeof(float));
271 av_cold
void ff_sipr_init_16k(SiprContext
*ctx
)
275 for (i
= 0; i
< LP_FILTER_ORDER_16k
; i
++)
276 ctx
->lsp_history_16k
[i
] = cos((i
+ 1) * M_PI
/(LP_FILTER_ORDER_16k
+ 1));
278 ctx
->filt_mem
[0] = ctx
->filt_buf
[0];
279 ctx
->filt_mem
[1] = ctx
->filt_buf
[1];
281 ctx
->pitch_lag_prev
= 180;