FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/sipr16k.c
Date: 2024-11-20 23:03:26
Exec Total Coverage
Lines: 100 101 99.0%
Functions: 10 10 100.0%
Branches: 23 24 95.8%
Line Branch Exec Source
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 FFmpeg.
8 *
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.
13 *
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.
18 *
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
22 */
23
24 #include <math.h>
25
26 #include "sipr.h"
27 #include "libavutil/attributes.h"
28 #include "libavutil/common.h"
29 #include "libavutil/float_dsp.h"
30 #include "libavutil/mathematics.h"
31 #include "lsp.h"
32 #include "acelp_vectors.h"
33 #include "acelp_pitch_delay.h"
34 #include "acelp_filters.h"
35 #include "celp_filters.h"
36
37 #include "sipr16kdata.h"
38
39 /**
40 * Convert an lsf vector into an lsp vector.
41 *
42 * @param lsf input lsf vector
43 * @param lsp output lsp vector
44 */
45 3260 static void lsf2lsp(const float *lsf, double *lsp)
46 {
47 int i;
48
49
2/2
✓ Branch 0 taken 52160 times.
✓ Branch 1 taken 3260 times.
 55420 for (i = 0; i < LP_FILTER_ORDER_16k; i++)
50 52160 lsp[i] = cosf(lsf[i]);
51 3260 }
52
53 3260 static void dequant(float *out, const int *idx, const float * const cbs[])
54 {
55 int i;
56
57
2/2
✓ Branch 0 taken 13040 times.
✓ Branch 1 taken 3260 times.
 16300 for (i = 0; i < 4; i++)
58 13040 memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float));
59
60 3260 memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float));
61 3260 }
62
63 3260 static void lsf_decode_fp_16k(float* lsf_history, float* isp_new,
64 const int* parm, int ma_pred)
65 {
66 int i;
67 float isp_q[LP_FILTER_ORDER_16k];
68
69 3260 dequant(isp_q, parm, lsf_codebooks_16k);
70
71
2/2
✓ Branch 0 taken 52160 times.
✓ Branch 1 taken 3260 times.
 55420 for (i = 0; i < LP_FILTER_ORDER_16k; i++) {
72 52160 isp_new[i] = (1 - qu[ma_pred]) * isp_q[i]
73 52160 + qu[ma_pred] * lsf_history[i]
74 52160 + mean_lsf_16k[i];
75 }
76
77 3260 memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float));
78 3260 }
79
80 3260 static int dec_delay3_1st(int index)
81 {
82
2/2
✓ Branch 0 taken 2245 times.
✓ Branch 1 taken 1015 times.
 3260 if (index < 390) {
83 2245 return index + 88;
84 } else
85 1015 return 3 * index - 690;
86 }
87
88 3260 static int dec_delay3_2nd(int index, int pit_min, int pit_max,
89 int pitch_lag_prev)
90 {
91
1/2
✓ Branch 0 taken 3260 times.
✗ Branch 1 not taken.
 3260 if (index < 62) {
92 3260 int pitch_delay_min = av_clip(pitch_lag_prev - 10,
93 pit_min, pit_max - 19);
94 3260 return 3 * pitch_delay_min + index - 2;
95 } else
96 ✗ return 3 * pitch_lag_prev;
97 }
98
99 3260 static void postfilter(float *out_data, float* synth, float* iir_mem,
100 float* filt_mem[2], float* mem_preemph)
101 {
102 float buf[30 + LP_FILTER_ORDER_16k];
103 3260 float *tmpbuf = buf + LP_FILTER_ORDER_16k;
104 float s;
105 int i;
106
107
2/2
✓ Branch 0 taken 52160 times.
✓ Branch 1 taken 3260 times.
 55420 for (i = 0; i < LP_FILTER_ORDER_16k; i++)
108 52160 filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i];
109
110 3260 memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph,
111 LP_FILTER_ORDER_16k*sizeof(*buf));
112
113 3260 ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30,
114 LP_FILTER_ORDER_16k);
115
116 3260 memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph,
117 LP_FILTER_ORDER_16k * sizeof(*synth));
118
119 3260 ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30,
120 LP_FILTER_ORDER_16k);
121
122 3260 memcpy(out_data + 30 - LP_FILTER_ORDER_16k,
123 3260 synth + 30 - LP_FILTER_ORDER_16k,
124 LP_FILTER_ORDER_16k * sizeof(*synth));
125
126 3260 ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0],
127 3260 synth + 30, 2 * L_SUBFR_16k - 30,
128 LP_FILTER_ORDER_16k);
129
130
131 3260 memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k,
132 LP_FILTER_ORDER_16k * sizeof(*synth));
133
134 3260 FFSWAP(float *, filt_mem[0], filt_mem[1]);
135
2/2
✓ Branch 0 taken 97800 times.
✓ Branch 1 taken 3260 times.
 101060 for (i = 0, s = 0; i < 30; i++, s += 1.0/30)
136 97800 out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]);
137 3260 }
138
139 /**
140 * Floating point version of ff_acelp_lp_decode().
141 */
142 3260 static void acelp_lp_decodef(float *lp_1st, float *lp_2nd,
143 const double *lsp_2nd, const double *lsp_prev)
144 {
145 double lsp_1st[LP_FILTER_ORDER_16k];
146 int i;
147
148 /* LSP values for first subframe (3.2.5 of G.729, Equation 24) */
149
2/2
✓ Branch 0 taken 52160 times.
✓ Branch 1 taken 3260 times.
 55420 for (i = 0; i < LP_FILTER_ORDER_16k; i++)
150 52160 lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5;
151
152 3260 ff_acelp_lspd2lpc(lsp_1st, lp_1st, LP_FILTER_ORDER_16k >> 1);
153
154 /* LSP values for second subframe (3.2.5 of G.729) */
155 3260 ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);
156 3260 }
157
158 /**
159 * Floating point version of ff_acelp_decode_gain_code().
160 */
161 6520 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)
165 {
166 6520 mr_energy += avpriv_scalarproduct_float_c(quant_energy, ma_prediction_coeff,
167 ma_pred_order);
168
169 13040 mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) /
170 6520 sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v, fc_v, subframe_size)));
171 6520 return mr_energy;
172 }
173
174 #define DIVIDE_BY_3(x) ((x) * 10923 >> 15)
175
176 3260 void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params,
177 float *out_data)
178 {
179 3260 int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;
180 3260 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;
186
187 int i;
188 int pitch_delay_3x;
189
190 3260 float *excitation = ctx->excitation + 292;
191
192 3260 lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes,
193 params->ma_pred_switch);
194
195 3260 ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);
196
197 3260 lsf2lsp(lsf_new, lsp_new);
198
199 3260 acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k);
200
201 3260 memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double));
202
203 3260 memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth,
204 LP_FILTER_ORDER_16k * sizeof(*synth));
205
206
2/2
✓ Branch 0 taken 6520 times.
✓ Branch 1 taken 3260 times.
 9780 for (i = 0; i < SUBFRAME_COUNT_16k; i++) {
207 6520 int i_subfr = i * L_SUBFR_16k;
208 AMRFixed f;
209 float gain_corr_factor;
210 int pitch_delay_int;
211 int pitch_delay_frac;
212
213
2/2
✓ Branch 0 taken 3260 times.
✓ Branch 1 taken 3260 times.
 6520 if (!i) {
214 3260 pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]);
215 } else
216 3260 pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i],
217 PITCH_MIN, PITCH_MAX,
218 ctx->pitch_lag_prev);
219
220 6520 pitch_fac = gain_pitch_cb_16k[params->gp_index[i]];
221
2/2
✓ Branch 0 taken 568 times.
✓ Branch 1 taken 5952 times.
 6520 f.pitch_fac = FFMIN(pitch_fac, 1.0);
222 6520 f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);
223 6520 ctx->pitch_lag_prev = f.pitch_lag;
224
225 6520 pitch_delay_int = DIVIDE_BY_3(pitch_delay_3x + 2);
226 6520 pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int;
227
228 6520 ff_acelp_interpolatef(&excitation[i_subfr],
229 6520 &excitation[i_subfr] - pitch_delay_int + 1,
230 sinc_win, 3, pitch_delay_frac + 1,
231 LP_FILTER_ORDER, L_SUBFR_16k);
232
233
234 6520 memset(fixed_vector, 0, sizeof(fixed_vector));
235
236 6520 ff_decode_10_pulses_35bits(params->fc_indexes[i], &f,
237 ff_fc_4pulses_8bits_tracks_13, 5, 4);
238
239 6520 ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k);
240
241 6520 gain_corr_factor = gain_cb_16k[params->gc_index[i]];
242 6520 gain_code = gain_corr_factor *
243 6520 acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector,
244 19.0 - 15.0/(0.05*M_LN10/M_LN2),
245 6520 pred_16k, ctx->energy_history,
246 L_SUBFR_16k, 2);
247
248 6520 ctx->energy_history[1] = ctx->energy_history[0];
249 6520 ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor);
250
251 6520 ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr],
252 fixed_vector, pitch_fac,
253 gain_code, L_SUBFR_16k);
254
255 6520 ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i],
256 6520 &excitation[i_subfr], L_SUBFR_16k,
257 LP_FILTER_ORDER_16k);
258
259 }
260 3260 memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k,
261 LP_FILTER_ORDER_16k * sizeof(*synth));
262
263 3260 memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k,
264 (L_INTERPOL+PITCH_MAX) * sizeof(float));
265
266 3260 postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph);
267
268 3260 memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float));
269 3260 }
270
271 2 av_cold void ff_sipr_init_16k(SiprContext *ctx)
272 {
273 int i;
274
275
2/2
✓ Branch 0 taken 32 times.
✓ Branch 1 taken 2 times.
 34 for (i = 0; i < LP_FILTER_ORDER_16k; i++)
276 32 ctx->lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1));
277
278 2 ctx->filt_mem[0] = ctx->filt_buf[0];
279 2 ctx->filt_mem[1] = ctx->filt_buf[1];
280
281 2 ctx->pitch_lag_prev = 180;
282 2 }
283