FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/sipr16k.c	Lines:	100	101	99.0 %
Date:	2020-10-23 17:01:47	Branches:	23	24	95.8 %


/*
 * SIPR decoder for the 16k mode
 *
 * Copyright (c) 2008 Vladimir Voroshilov
 * Copyright (c) 2009 Vitor Sessak
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <math.h>

#include "sipr.h"
#include "libavutil/attributes.h"
#include "libavutil/common.h"
#include "libavutil/float_dsp.h"
#include "libavutil/mathematics.h"
#include "lsp.h"
#include "acelp_vectors.h"
#include "acelp_pitch_delay.h"
#include "acelp_filters.h"
#include "celp_filters.h"

#include "sipr16kdata.h"

/**
 * Convert an lsf vector into an lsp vector.
 *
 * @param lsf               input lsf vector
 * @param lsp               output lsp vector
 */
static void lsf2lsp(const float *lsf, double *lsp)
{
    int i;

    for (i = 0; i < LP_FILTER_ORDER_16k; i++)
        lsp[i] = cosf(lsf[i]);
}

static void dequant(float *out, const int *idx, const float * const cbs[])
{
    int i;

    for (i = 0; i < 4; i++)
        memcpy(out + 3*i, cbs[i] + 3*idx[i], 3*sizeof(float));

    memcpy(out + 12, cbs[4] + 4*idx[4], 4*sizeof(float));
}

static void lsf_decode_fp_16k(float* lsf_history, float* isp_new,
                              const int* parm, int ma_pred)
{
    int i;
    float isp_q[LP_FILTER_ORDER_16k];

    dequant(isp_q, parm, lsf_codebooks_16k);

    for (i = 0; i < LP_FILTER_ORDER_16k; i++) {
        isp_new[i] = (1 - qu[ma_pred]) * isp_q[i]
                    +     qu[ma_pred]  * lsf_history[i]
                    + mean_lsf_16k[i];
    }

    memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float));
}

static int dec_delay3_1st(int index)
{
    if (index < 390) {
        return index + 88;
    } else
        return 3 * index - 690;
}

static int dec_delay3_2nd(int index, int pit_min, int pit_max,
                          int pitch_lag_prev)
{
    if (index < 62) {
        int pitch_delay_min = av_clip(pitch_lag_prev - 10,
                                      pit_min, pit_max - 19);
        return 3 * pitch_delay_min + index - 2;
    } else
        return 3 * pitch_lag_prev;
}

static void postfilter(float *out_data, float* synth, float* iir_mem,
                       float* filt_mem[2], float* mem_preemph)
{
    float buf[30 + LP_FILTER_ORDER_16k];
    float *tmpbuf = buf + LP_FILTER_ORDER_16k;
    float s;
    int i;

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

    memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph,
           LP_FILTER_ORDER_16k*sizeof(*buf));

    ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30,
                                 LP_FILTER_ORDER_16k);

    memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph,
           LP_FILTER_ORDER_16k * sizeof(*synth));

    ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30,
                                 LP_FILTER_ORDER_16k);

    memcpy(out_data + 30 - LP_FILTER_ORDER_16k,
           synth    + 30 - LP_FILTER_ORDER_16k,
           LP_FILTER_ORDER_16k * sizeof(*synth));

    ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0],
                                 synth + 30, 2 * L_SUBFR_16k - 30,
                                 LP_FILTER_ORDER_16k);


    memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k,
           LP_FILTER_ORDER_16k * sizeof(*synth));

    FFSWAP(float *, filt_mem[0], filt_mem[1]);
    for (i = 0, s = 0; i < 30; i++, s += 1.0/30)
        out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]);
}

/**
 * Floating point version of ff_acelp_lp_decode().
 */
static void acelp_lp_decodef(float *lp_1st, float *lp_2nd,
                             const double *lsp_2nd, const double *lsp_prev)
{
    double lsp_1st[LP_FILTER_ORDER_16k];
    int i;

    /* LSP values for first subframe (3.2.5 of G.729, Equation 24) */
    for (i = 0; i < LP_FILTER_ORDER_16k; i++)
        lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5;

    ff_acelp_lspd2lpc(lsp_1st, lp_1st, LP_FILTER_ORDER_16k >> 1);

    /* LSP values for second subframe (3.2.5 of G.729) */
    ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);
}

/**
 * Floating point version of ff_acelp_decode_gain_code().
 */
static float acelp_decode_gain_codef(float gain_corr_factor, const float *fc_v,
                                     float mr_energy, const float *quant_energy,
                                     const float *ma_prediction_coeff,
                                     int subframe_size, int ma_pred_order)
{
    mr_energy += avpriv_scalarproduct_float_c(quant_energy, ma_prediction_coeff,
                                              ma_pred_order);

    mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) /
        sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v, fc_v, subframe_size)));
    return mr_energy;
}

#define DIVIDE_BY_3(x) ((x) * 10923 >> 15)

void ff_sipr_decode_frame_16k(SiprContext *ctx, SiprParameters *params,
                              float *out_data)
{
    int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;
    float *synth = ctx->synth_buf + LP_FILTER_ORDER_16k;
    float lsf_new[LP_FILTER_ORDER_16k];
    double lsp_new[LP_FILTER_ORDER_16k];
    float Az[2][LP_FILTER_ORDER_16k];
    float fixed_vector[L_SUBFR_16k];
    float pitch_fac, gain_code;

    int i;
    int pitch_delay_3x;

    float *excitation = ctx->excitation + 292;

    lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes,
                      params->ma_pred_switch);

    ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);

    lsf2lsp(lsf_new, lsp_new);

    acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k);

    memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double));

    memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth,
           LP_FILTER_ORDER_16k * sizeof(*synth));

    for (i = 0; i < SUBFRAME_COUNT_16k; i++) {
        int i_subfr = i * L_SUBFR_16k;
        AMRFixed f;
        float gain_corr_factor;
        int pitch_delay_int;
        int pitch_delay_frac;

        if (!i) {
            pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]);
        } else
            pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i],
                                            PITCH_MIN, PITCH_MAX,
                                            ctx->pitch_lag_prev);

        pitch_fac = gain_pitch_cb_16k[params->gp_index[i]];
        f.pitch_fac = FFMIN(pitch_fac, 1.0);
        f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);
        ctx->pitch_lag_prev = f.pitch_lag;

        pitch_delay_int  = DIVIDE_BY_3(pitch_delay_3x + 2);
        pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int;

        ff_acelp_interpolatef(&excitation[i_subfr],
                              &excitation[i_subfr] - pitch_delay_int + 1,
                              sinc_win, 3, pitch_delay_frac + 1,
                              LP_FILTER_ORDER, L_SUBFR_16k);


        memset(fixed_vector, 0, sizeof(fixed_vector));

        ff_decode_10_pulses_35bits(params->fc_indexes[i], &f,
                                   ff_fc_4pulses_8bits_tracks_13, 5, 4);

        ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k);

        gain_corr_factor = gain_cb_16k[params->gc_index[i]];
        gain_code = gain_corr_factor *
            acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector,
                                    19.0 - 15.0/(0.05*M_LN10/M_LN2),
                                    pred_16k, ctx->energy_history,
                                    L_SUBFR_16k, 2);

        ctx->energy_history[1] = ctx->energy_history[0];
        ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor);

        ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr],
                                fixed_vector, pitch_fac,
                                gain_code, L_SUBFR_16k);

        ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i],
                                     &excitation[i_subfr], L_SUBFR_16k,
                                     LP_FILTER_ORDER_16k);

    }
    memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k,
           LP_FILTER_ORDER_16k * sizeof(*synth));

    memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k,
            (L_INTERPOL+PITCH_MAX) * sizeof(float));

    postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph);

    memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float));
}

av_cold void ff_sipr_init_16k(SiprContext *ctx)
{
    int i;

    for (i = 0; i < LP_FILTER_ORDER_16k; i++)
        ctx->lsp_history_16k[i] = cos((i + 1) * M_PI/(LP_FILTER_ORDER_16k + 1));

    ctx->filt_mem[0] = ctx->filt_buf[0];
    ctx->filt_mem[1] = ctx->filt_buf[1];

    ctx->pitch_lag_prev = 180;
}


Generated by: GCOVR (Version 4.2)

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		3250	static void lsf2lsp(const float lsf, double lsp)
46			{
47			int i;
48
49	✓✓	55250	for (i = 0; i < LP_FILTER_ORDER_16k; i++)
50		52000	lsp[i] = cosf(lsf[i]);
51		3250	}
52
53		3250	static void dequant(float out, const int idx, const float * const cbs[])
54			{
55			int i;
56
57	✓✓	16250	for (i = 0; i < 4; i++)
58		13000	memcpy(out + 3i, cbs[i] + 3idx[i], 3*sizeof(float));
59
60		3250	memcpy(out + 12, cbs[4] + 4idx[4], 4sizeof(float));
61		3250	}
62
63		3250	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		3250	dequant(isp_q, parm, lsf_codebooks_16k);
70
71	✓✓	55250	for (i = 0; i < LP_FILTER_ORDER_16k; i++) {
72		52000	isp_new[i] = (1 - qu[ma_pred]) * isp_q[i]
73		52000	+ qu[ma_pred] * lsf_history[i]
74		52000	+ mean_lsf_16k[i];
75			}
76
77		3250	memcpy(lsf_history, isp_q, LP_FILTER_ORDER_16k * sizeof(float));
78		3250	}
79
80		3250	static int dec_delay3_1st(int index)
81			{
82	✓✓	3250	if (index < 390) {
83		2237	return index + 88;
84			} else
85		1013	return 3 * index - 690;
86			}
87
88		3250	static int dec_delay3_2nd(int index, int pit_min, int pit_max,
89			int pitch_lag_prev)
90			{
91	✓✗	3250	if (index < 62) {
92		3250	int pitch_delay_min = av_clip(pitch_lag_prev - 10,
93			pit_min, pit_max - 19);
94		3250	return 3 * pitch_delay_min + index - 2;
95			} else
96			return 3 * pitch_lag_prev;
97			}
98
99		3250	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		3250	float *tmpbuf = buf + LP_FILTER_ORDER_16k;
104			float s;
105			int i;
106
107	✓✓	55250	for (i = 0; i < LP_FILTER_ORDER_16k; i++)
108		52000	filt_mem[0][i] = iir_mem[i] * ff_pow_0_5[i];
109
110		3250	memcpy(tmpbuf - LP_FILTER_ORDER_16k, mem_preemph,
111			LP_FILTER_ORDER_16ksizeof(buf));
112
113		3250	ff_celp_lp_synthesis_filterf(tmpbuf, filt_mem[1], synth, 30,
114			LP_FILTER_ORDER_16k);
115
116		3250	memcpy(synth - LP_FILTER_ORDER_16k, mem_preemph,
117			LP_FILTER_ORDER_16k * sizeof(*synth));
118
119		3250	ff_celp_lp_synthesis_filterf(synth, filt_mem[0], synth, 30,
120			LP_FILTER_ORDER_16k);
121
122		3250	memcpy(out_data + 30 - LP_FILTER_ORDER_16k,
123		3250	synth + 30 - LP_FILTER_ORDER_16k,
124			LP_FILTER_ORDER_16k * sizeof(*synth));
125
126		3250	ff_celp_lp_synthesis_filterf(out_data + 30, filt_mem[0],
127		3250	synth + 30, 2 * L_SUBFR_16k - 30,
128			LP_FILTER_ORDER_16k);
129
130
131		3250	memcpy(mem_preemph, out_data + 2*L_SUBFR_16k - LP_FILTER_ORDER_16k,
132			LP_FILTER_ORDER_16k * sizeof(*synth));
133
134		3250	FFSWAP(float *, filt_mem[0], filt_mem[1]);
135	✓✓	100750	for (i = 0, s = 0; i < 30; i++, s += 1.0/30)
136		97500	out_data[i] = tmpbuf[i] + s * (synth[i] - tmpbuf[i]);
137		3250	}
138
139			/**
140			* Floating point version of ff_acelp_lp_decode().
141			*/
142		3250	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	✓✓	55250	for (i = 0; i < LP_FILTER_ORDER_16k; i++)
150		52000	lsp_1st[i] = (lsp_2nd[i] + lsp_prev[i]) * 0.5;
151
152		3250	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		3250	ff_acelp_lspd2lpc(lsp_2nd, lp_2nd, LP_FILTER_ORDER_16k >> 1);
156		3250	}
157
158			/**
159			* Floating point version of ff_acelp_decode_gain_code().
160			*/
161		6500	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		6500	mr_energy += avpriv_scalarproduct_float_c(quant_energy, ma_prediction_coeff,
167			ma_pred_order);
168
169		13000	mr_energy = gain_corr_factor * exp(M_LN10 / 20. * mr_energy) /
170		6500	sqrt((0.01 + avpriv_scalarproduct_float_c(fc_v, fc_v, subframe_size)));
171		6500	return mr_energy;
172			}
173
174			#define DIVIDE_BY_3(x) ((x) * 10923 >> 15)
175
176		3250	void ff_sipr_decode_frame_16k(SiprContext ctx, SiprParameters params,
177			float *out_data)
178			{
179		3250	int frame_size = SUBFRAME_COUNT_16k * L_SUBFR_16k;
180		3250	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		3250	float *excitation = ctx->excitation + 292;
191
192		3250	lsf_decode_fp_16k(ctx->lsf_history, lsf_new, params->vq_indexes,
193			params->ma_pred_switch);
194
195		3250	ff_set_min_dist_lsf(lsf_new, LSFQ_DIFF_MIN / 2, LP_FILTER_ORDER_16k);
196
197		3250	lsf2lsp(lsf_new, lsp_new);
198
199		3250	acelp_lp_decodef(Az[0], Az[1], lsp_new, ctx->lsp_history_16k);
200
201		3250	memcpy(ctx->lsp_history_16k, lsp_new, LP_FILTER_ORDER_16k * sizeof(double));
202
203		3250	memcpy(synth - LP_FILTER_ORDER_16k, ctx->synth,
204			LP_FILTER_ORDER_16k * sizeof(*synth));
205
206	✓✓	9750	for (i = 0; i < SUBFRAME_COUNT_16k; i++) {
207		6500	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	✓✓	6500	if (!i) {
214		3250	pitch_delay_3x = dec_delay3_1st(params->pitch_delay[i]);
215			} else
216		3250	pitch_delay_3x = dec_delay3_2nd(params->pitch_delay[i],
217			PITCH_MIN, PITCH_MAX,
218			ctx->pitch_lag_prev);
219
220		6500	pitch_fac = gain_pitch_cb_16k[params->gp_index[i]];
221	✓✓	6500	f.pitch_fac = FFMIN(pitch_fac, 1.0);
222		6500	f.pitch_lag = DIVIDE_BY_3(pitch_delay_3x+1);
223		6500	ctx->pitch_lag_prev = f.pitch_lag;
224
225		6500	pitch_delay_int = DIVIDE_BY_3(pitch_delay_3x + 2);
226		6500	pitch_delay_frac = pitch_delay_3x + 2 - 3*pitch_delay_int;
227
228		6500	ff_acelp_interpolatef(&excitation[i_subfr],
229		6500	&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		6500	memset(fixed_vector, 0, sizeof(fixed_vector));
235
236		6500	ff_decode_10_pulses_35bits(params->fc_indexes[i], &f,
237			ff_fc_4pulses_8bits_tracks_13, 5, 4);
238
239		6500	ff_set_fixed_vector(fixed_vector, &f, 1.0, L_SUBFR_16k);
240
241		6500	gain_corr_factor = gain_cb_16k[params->gc_index[i]];
242		6500	gain_code = gain_corr_factor *
243		6500	acelp_decode_gain_codef(sqrt(L_SUBFR_16k), fixed_vector,
244			19.0 - 15.0/(0.05*M_LN10/M_LN2),
245		6500	pred_16k, ctx->energy_history,
246			L_SUBFR_16k, 2);
247
248		6500	ctx->energy_history[1] = ctx->energy_history[0];
249		6500	ctx->energy_history[0] = 20.0 * log10f(gain_corr_factor);
250
251		6500	ff_weighted_vector_sumf(&excitation[i_subfr], &excitation[i_subfr],
252			fixed_vector, pitch_fac,
253			gain_code, L_SUBFR_16k);
254
255		6500	ff_celp_lp_synthesis_filterf(synth + i_subfr, Az[i],
256		6500	&excitation[i_subfr], L_SUBFR_16k,
257			LP_FILTER_ORDER_16k);
258
259			}
260		3250	memcpy(ctx->synth, synth + frame_size - LP_FILTER_ORDER_16k,
261			LP_FILTER_ORDER_16k * sizeof(*synth));
262
263		3250	memmove(ctx->excitation, ctx->excitation + 2 * L_SUBFR_16k,
264			(L_INTERPOL+PITCH_MAX) * sizeof(float));
265
266		3250	postfilter(out_data, synth, ctx->iir_mem, ctx->filt_mem, ctx->mem_preemph);
267
268		3250	memcpy(ctx->iir_mem, Az[1], LP_FILTER_ORDER_16k * sizeof(float));
269		3250	}
270
271		2	av_cold void ff_sipr_init_16k(SiprContext *ctx)
272			{
273			int i;
274
275	✓✓	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	}