sipr16k.c
Go to the documentation of this file.
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 02110-1301 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 
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 
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 
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 
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 
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],
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,
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,
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 
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 }