ffmpeg / libavcodec / sipr16k.c @ 2912e87a
History  View  Annotate  Download (9 KB)
1 
/*


2 
* SIPR decoder for the 16k mode

3 
*

4 
* Copyright (c) 2008 Vladimir Voroshilov

5 
* Copyright (c) 2009 Vitor Sessak

6 
*

7 
* This file is part of Libav.

8 
*

9 
* Libav 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.

13 
*

14 
* Libav 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.

18 
*

19 
* You should have received a copy of the GNU Lesser General Public

20 
* License along with Libav; if not, write to the Free Software

21 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

22 
*/

23  
24 
#include <math.h> 
25  
26 
#include "sipr.h" 
27 
#include "libavutil/mathematics.h" 
28 
#include "lsp.h" 
29 
#include "celp_math.h" 
30 
#include "acelp_vectors.h" 
31 
#include "acelp_pitch_delay.h" 
32 
#include "acelp_filters.h" 
33 
#include "celp_filters.h" 
34  
35 
#include "sipr16kdata.h" 
36  
37 
/**

38 
* Convert an lsf vector into an lsp vector.

39 
*

40 
* @param lsf input lsf vector

41 
* @param lsp output lsp vector

42 
*/

43 
static void lsf2lsp(const float *lsf, double *lsp) 
44 
{ 
45 
int i;

46  
47 
for (i = 0; i < LP_FILTER_ORDER_16k; i++) 
48 
lsp[i] = cosf(lsf[i]); 
49 
} 
50  
51 
static void dequant(float *out, const int *idx, const float *cbs[]) 
52 
{ 
53 
int i;

54  
55 
for (i = 0; i < 4; i++) 
56 
memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float)); 
57  
58 
memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float)); 
59 
} 
60  
61 
static void lsf_decode_fp_16k(float* lsf_history, float* isp_new, 
62 
const int* parm, int ma_pred) 
63 
{ 
64 
int i;

65 
float isp_q[LP_FILTER_ORDER_16k];

66  
67 
dequant(isp_q, parm, lsf_codebooks_16k); 
68  
69 
for (i = 0; i < LP_FILTER_ORDER_16k; i++) { 
70 
isp_new[i] = (1  qu[ma_pred]) * isp_q[i]

71 
+ qu[ma_pred] * lsf_history[i] 
72 
+ mean_lsf_16k[i]; 
73 
} 
74  
75 
memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float)); 
76 
} 
77  
78 
static int dec_delay3_1st(int index) 
79 
{ 
80 
if (index < 390) { 
81 
return index + 88; 
82 
} else

83 
return 3 * index  690; 
84 
} 
85  
86 
static int dec_delay3_2nd(int index, int pit_min, int pit_max, 
87 
int pitch_lag_prev)

88 
{ 
89 
if (index < 62) { 
90 
int pitch_delay_min = av_clip(pitch_lag_prev  10, 
91 
pit_min, pit_max  19);

92 
return 3 * pitch_delay_min + index  2; 
93 
} else

94 
return 3 * pitch_lag_prev; 
95 
} 
96  
97 
static void postfilter(float *out_data, float* synth, float* iir_mem, 
98 
float* filt_mem[2], float* mem_preemph) 
99 
{ 
100 
float buf[30 + LP_FILTER_ORDER_16k]; 
101 
float *tmpbuf = buf + LP_FILTER_ORDER_16k;

102 
float s;

103 
int i;

104  
105 
for (i = 0; i < LP_FILTER_ORDER_16k; i++) 
106 
filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i];

107  
108 
memcpy(tmpbuf  LP_FILTER_ORDER_16k, mem_preemph, 
109 
LP_FILTER_ORDER_16k*sizeof(*buf));

110  
111 
ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30, 
112 
LP_FILTER_ORDER_16k); 
113  
114 
memcpy(synth  LP_FILTER_ORDER_16k, mem_preemph, 
115 
LP_FILTER_ORDER_16k * sizeof(*synth));

116  
117 
ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30, 
118 
LP_FILTER_ORDER_16k); 
119  
120 
memcpy(out_data + 30  LP_FILTER_ORDER_16k,

121 
synth + 30  LP_FILTER_ORDER_16k,

122 
LP_FILTER_ORDER_16k * sizeof(*synth));

123  
124 
ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0], 
125 
synth + 30, 2 * L_SUBFR_16k  30, 
126 
LP_FILTER_ORDER_16k); 
127  
128  
129 
memcpy(mem_preemph, out_data + 2*L_SUBFR_16k  LP_FILTER_ORDER_16k,

130 
LP_FILTER_ORDER_16k * sizeof(*synth));

131  
132 
FFSWAP(float *, filt_mem[0], filt_mem[1]); 
133 
for (i = 0, s = 0; i < 30; i++, s += 1.0/30) 
134 
out_data[i] = tmpbuf[i] + s * (synth[i]  tmpbuf[i]); 
135 
} 
136  
137 
/**

138 
* Floating point version of ff_acelp_lp_decode().

139 
*/

140 
static void acelp_lp_decodef(float *lp_1st, float *lp_2nd, 
141 
const double *lsp_2nd, const double *lsp_prev) 
142 
{ 
143 
double lsp_1st[LP_FILTER_ORDER_16k];

144 
int i;

145  
146 
/* LSP values for first subframe (3.2.5 of G.729, Equation 24) */

147 
for (i = 0; i < LP_FILTER_ORDER_16k; i++) 
148 
lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5; 
149  
150 
ff_acelp_lspd2lpc(lsp_1st, lp_1st, LP_FILTER_ORDER_16k >> 1);

151  
152 
/* LSP values for second subframe (3.2.5 of G.729) */

153 
ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);

154 
} 
155  
156 
/**

157 
* Floating point version of ff_acelp_decode_gain_code().

158 
*/

159 
static float acelp_decode_gain_codef(float gain_corr_factor, const float *fc_v, 
160 
float mr_energy, const float *quant_energy, 
161 
const float *ma_prediction_coeff, 
162 
int subframe_size, int ma_pred_order) 
163 
{ 
164 
mr_energy += 
165 
ff_dot_productf(quant_energy, ma_prediction_coeff, ma_pred_order); 
166  
167 
mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) / 
168 
sqrt((0.01 + ff_dot_productf(fc_v, fc_v, subframe_size))); 
169 
return mr_energy;

170 
} 
171  
172 
#define DIVIDE_BY_3(x) ((x) * 10923 >> 15) 
173  
174 
void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params,

175 
float *out_data)

176 
{ 
177 
int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;

178 
float *synth = ctx>synth_buf + LP_FILTER_ORDER_16k;

179 
float lsf_new[LP_FILTER_ORDER_16k];

180 
double lsp_new[LP_FILTER_ORDER_16k];

181 
float Az[2][LP_FILTER_ORDER_16k]; 
182 
float fixed_vector[L_SUBFR_16k];

183 
float pitch_fac, gain_code;

184  
185 
int i;

186 
int pitch_delay_3x;

187  
188 
float *excitation = ctx>excitation + 292; 
189  
190 
lsf_decode_fp_16k(ctx>lsf_history, lsf_new, params>vq_indexes, 
191 
params>ma_pred_switch); 
192  
193 
ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);

194  
195 
lsf2lsp(lsf_new, lsp_new); 
196  
197 
acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx>lsp_history_16k); 
198  
199 
memcpy(ctx>lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double)); 
200  
201 
memcpy(synth  LP_FILTER_ORDER_16k, ctx>synth, 
202 
LP_FILTER_ORDER_16k * sizeof(*synth));

203  
204 
for (i = 0; i < SUBFRAME_COUNT_16k; i++) { 
205 
int i_subfr = i * L_SUBFR_16k;

206 
AMRFixed f; 
207 
float gain_corr_factor;

208 
int pitch_delay_int;

209 
int pitch_delay_frac;

210  
211 
if (!i) {

212 
pitch_delay_3x = dec_delay3_1st(params>pitch_delay[i]); 
213 
} else

214 
pitch_delay_3x = dec_delay3_2nd(params>pitch_delay[i], 
215 
PITCH_MIN, PITCH_MAX, 
216 
ctx>pitch_lag_prev); 
217  
218 
pitch_fac = gain_pitch_cb_16k[params>gp_index[i]]; 
219 
f.pitch_fac = FFMIN(pitch_fac, 1.0); 
220 
f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);

221 
ctx>pitch_lag_prev = f.pitch_lag; 
222  
223 
pitch_delay_int = DIVIDE_BY_3(pitch_delay_3x + 2);

224 
pitch_delay_frac = pitch_delay_3x + 2  3*pitch_delay_int; 
225  
226 
ff_acelp_interpolatef(&excitation[i_subfr], 
227 
&excitation[i_subfr]  pitch_delay_int + 1,

228 
sinc_win, 3, pitch_delay_frac + 1, 
229 
LP_FILTER_ORDER, L_SUBFR_16k); 
230  
231  
232 
memset(fixed_vector, 0, sizeof(fixed_vector)); 
233  
234 
ff_decode_10_pulses_35bits(params>fc_indexes[i], &f, 
235 
ff_fc_4pulses_8bits_tracks_13, 5, 4); 
236  
237 
ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k); 
238  
239 
gain_corr_factor = gain_cb_16k[params>gc_index[i]]; 
240 
gain_code = gain_corr_factor * 
241 
acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector, 
242 
19.0  15.0/(0.05*M_LN10/M_LN2), 
243 
pred_16k, ctx>energy_history, 
244 
L_SUBFR_16k, 2);

245  
246 
ctx>energy_history[1] = ctx>energy_history[0]; 
247 
ctx>energy_history[0] = 20.0 * log10f(gain_corr_factor); 
248  
249 
ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr], 
250 
fixed_vector, pitch_fac, 
251 
gain_code, L_SUBFR_16k); 
252  
253 
ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i], 
254 
&excitation[i_subfr], L_SUBFR_16k, 
255 
LP_FILTER_ORDER_16k); 
256  
257 
} 
258 
memcpy(ctx>synth, synth + frame_size  LP_FILTER_ORDER_16k, 
259 
LP_FILTER_ORDER_16k * sizeof(*synth));

260  
261 
memmove(ctx>excitation, ctx>excitation + 2 * L_SUBFR_16k,

262 
(L_INTERPOL+PITCH_MAX) * sizeof(float)); 
263  
264 
postfilter(out_data, synth, ctx>iir_mem, ctx>filt_mem, ctx>mem_preemph); 
265  
266 
memcpy(ctx>iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float)); 
267 
} 
268  
269 
void ff_sipr_init_16k(SiprContext *ctx)

270 
{ 
271 
int i;

272  
273 
for (i = 0; i < LP_FILTER_ORDER_16k; i++) 
274 
ctx>lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1)); 
275  
276 
ctx>filt_mem[0] = ctx>filt_buf[0]; 
277 
ctx>filt_mem[1] = ctx>filt_buf[1]; 
278  
279 
ctx>pitch_lag_prev = 180;

280 
} 