FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/dialoguenhance_template.c
Date:	2024-05-03 15:42:48

	Total	Coverage
Lines:	134	0.0%
Functions:	16	0.0%
Branches:	24	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * 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 "libavutil/mem.h"
    
      #include "libavutil/tx.h"
    
      #include "avfilter.h"
    
      #include "internal.h"
    
      #include "audio.h"
    
      #undef ctype
    
      #undef ftype
    
      #undef SQRT
    
      #undef HYPOT
    
      #undef SAMPLE_FORMAT
    
      #undef TX_TYPE
    
      #undef ONE
    
      #undef ZERO
    
      #undef HALF
    
      #undef SIN
    
      #undef CLIP
    
      #undef EPSILON
    
      #if DEPTH == 32
    
      #define SAMPLE_FORMAT float
    
      #define SQRT sqrtf
    
      #define HYPOT hypotf
    
      #define ctype AVComplexFloat
    
      #define ftype float
    
      #define TX_TYPE AV_TX_FLOAT_RDFT
    
      #define ONE 1.f
    
      #define ZERO 0.f
    
      #define HALF 0.5f
    
      #define SIN sinf
    
      #define CLIP av_clipf
    
      #define EPSILON FLT_EPSILON
    
      #else
    
      #define SAMPLE_FORMAT double
    
      #define SQRT sqrt
    
      #define HYPOT hypot
    
      #define ctype AVComplexDouble
    
      #define ftype double
    
      #define TX_TYPE AV_TX_DOUBLE_RDFT
    
      #define ONE 1.0
    
      #define ZERO 0.0
    
      #define HALF 0.5
    
      #define SIN sin
    
      #define CLIP av_clipd
    
      #define EPSILON DBL_EPSILON
    
      #endif
    
      #define fn3(a,b)   a##_##b
    
      #define fn2(a,b)   fn3(a,b)
    
      #define fn(a)      fn2(a, SAMPLE_FORMAT)
    
      ✗
      static int fn(de_tx_init)(AVFilterContext *ctx)
    
      {
    
      ✗
          AudioDialogueEnhanceContext *s = ctx->priv;
    
      ✗
          ftype scale = ONE, iscale = ONE / (s->fft_size * 1.5f);
    
          int ret;
    
      ✗
          s->window = av_calloc(s->fft_size, sizeof(ftype));
    
      ✗
          if (!s->window)
    
      ✗
              return AVERROR(ENOMEM);
    
      ✗
          fn(s->window) = s->window;
    
      ✗
          for (int n = 0; n < s->fft_size; n++)
    
      ✗
              fn(s->window)[n] = SIN(M_PI*n/(s->fft_size-1));
    
      ✗
          ret = av_tx_init(&s->tx_ctx[0], &s->tx_fn, TX_TYPE, 0, s->fft_size, &scale, 0);
    
      ✗
          if (ret < 0)
    
      ✗
              return ret;
    
      ✗
          ret = av_tx_init(&s->tx_ctx[1], &s->tx_fn, TX_TYPE, 0, s->fft_size, &scale, 0);
    
      ✗
          if (ret < 0)
    
      ✗
              return ret;
    
      ✗
          ret = av_tx_init(&s->itx_ctx, &s->itx_fn, TX_TYPE, 1, s->fft_size, &iscale, 0);
    
      ✗
          if (ret < 0)
    
      ✗
              return ret;
    
      ✗
          return 0;
    
      }
    
      ✗
      static void fn(apply_window)(AudioDialogueEnhanceContext *s,
    
                                   const ftype *in_frame, ftype *out_frame, const int add_to_out_frame)
    
      {
    
      ✗
          const ftype *window = fn(s->window);
    
      ✗
          const int fft_size = s->fft_size;
    
      ✗
          if (add_to_out_frame) {
    
      ✗
              for (int i = 0; i < fft_size; i++)
    
      ✗
                  out_frame[i] += in_frame[i] * window[i];
    
          } else {
    
      ✗
              for (int i = 0; i < fft_size; i++)
    
      ✗
                  out_frame[i] = in_frame[i] * window[i];
    
          }
    
      ✗
      }
    
      ✗
      static ftype fn(sqr)(ftype x)
    
      {
    
      ✗
          return x * x;
    
      }
    
      ✗
      static void fn(get_centere)(ctype *left, ctype *right,
    
                                  ctype *center, int N)
    
      {
    
      ✗
          for (int i = 0; i < N; i++) {
    
      ✗
              const ftype l_re = left[i].re;
    
      ✗
              const ftype l_im = left[i].im;
    
      ✗
              const ftype r_re = right[i].re;
    
      ✗
              const ftype r_im = right[i].im;
    
      ✗
              const ftype a = HALF * (ONE - SQRT((fn(sqr)(l_re - r_re) + fn(sqr)(l_im - r_im))/
    
      ✗
                                                 (fn(sqr)(l_re + r_re) + fn(sqr)(l_im + r_im) + EPSILON)));
    
      ✗
              center[i].re = a * (l_re + r_re);
    
      ✗
              center[i].im = a * (l_im + r_im);
    
          }
    
      ✗
      }
    
      ✗
      static ftype fn(flux)(ftype *curf, ftype *prevf, int N)
    
      {
    
      ✗
          ctype *cur  = (ctype *)curf;
    
      ✗
          ctype *prev = (ctype *)prevf;
    
      ✗
          ftype sum = ZERO;
    
      ✗
          for (int i = 0; i < N; i++) {
    
      ✗
              ftype c_re = cur[i].re;
    
      ✗
              ftype c_im = cur[i].im;
    
      ✗
              ftype p_re = prev[i].re;
    
      ✗
              ftype p_im = prev[i].im;
    
      ✗
              sum += fn(sqr)(HYPOT(c_re, c_im) - HYPOT(p_re, p_im));
    
          }
    
      ✗
          return sum;
    
      }
    
      ✗
      static ftype fn(fluxlr)(ftype *lf, ftype *lpf,
    
                              ftype *rf, ftype *rpf,
    
                              int N)
    
      {
    
      ✗
          ctype *l  = (ctype *)lf;
    
      ✗
          ctype *lp = (ctype *)lpf;
    
      ✗
          ctype *r  = (ctype *)rf;
    
      ✗
          ctype *rp = (ctype *)rpf;
    
      ✗
          ftype sum = ZERO;
    
      ✗
          for (int i = 0; i < N; i++) {
    
      ✗
              ftype c_re = l[i].re - r[i].re;
    
      ✗
              ftype c_im = l[i].im - r[i].im;
    
      ✗
              ftype p_re = lp[i].re - rp[i].re;
    
      ✗
              ftype p_im = lp[i].im - rp[i].im;
    
      ✗
              sum += fn(sqr)(HYPOT(c_re, c_im) - HYPOT(p_re, p_im));
    
          }
    
      ✗
          return sum;
    
      }
    
      ✗
      static ftype fn(calc_vad)(ftype fc, ftype flr, ftype a)
    
      {
    
      ✗
          const ftype vad = a * (fc / (fc + flr) - HALF);
    
      ✗
          return CLIP(vad, ZERO, ONE);
    
      }
    
      ✗
      static void fn(get_final)(ftype *c, ftype *l,
    
                                ftype *r, ftype vad, int N,
    
                                ftype original, ftype enhance)
    
      {
    
      ✗
          ctype *center = (ctype *)c;
    
      ✗
          ctype *left   = (ctype *)l;
    
      ✗
          ctype *right  = (ctype *)r;
    
      ✗
          for (int i = 0; i < N; i++) {
    
      ✗
              ftype cP = fn(sqr)(center[i].re) + fn(sqr)(center[i].im);
    
      ✗
              ftype lrP = fn(sqr)(left[i].re - right[i].re) + fn(sqr)(left[i].im - right[i].im);
    
      ✗
              ftype G = cP / (cP + lrP + EPSILON);
    
              ftype re, im;
    
      ✗
              re = center[i].re * (original + vad * G * enhance);
    
      ✗
              im = center[i].im * (original + vad * G * enhance);
    
      ✗
              center[i].re = re;
    
      ✗
              center[i].im = im;
    
          }
    
      ✗
      }
    
      ✗
      static int fn(de_stereo)(AVFilterContext *ctx, AVFrame *out)
    
      {
    
      ✗
          AudioDialogueEnhanceContext *s = ctx->priv;
    
      ✗
          ftype *center          = (ftype *)s->center_frame->extended_data[0];
    
      ✗
          ftype *center_prev     = (ftype *)s->center_frame->extended_data[1];
    
      ✗
          ftype *left_in         = (ftype *)s->in_frame->extended_data[0];
    
      ✗
          ftype *right_in        = (ftype *)s->in_frame->extended_data[1];
    
      ✗
          ftype *left_out        = (ftype *)s->out_dist_frame->extended_data[0];
    
      ✗
          ftype *right_out       = (ftype *)s->out_dist_frame->extended_data[1];
    
      ✗
          ftype *left_samples    = (ftype *)s->in->extended_data[0];
    
      ✗
          ftype *right_samples   = (ftype *)s->in->extended_data[1];
    
      ✗
          ftype *windowed_left   = (ftype *)s->windowed_frame->extended_data[0];
    
      ✗
          ftype *windowed_right  = (ftype *)s->windowed_frame->extended_data[1];
    
      ✗
          ftype *windowed_oleft  = (ftype *)s->windowed_out->extended_data[0];
    
      ✗
          ftype *windowed_oright = (ftype *)s->windowed_out->extended_data[1];
    
      ✗
          ftype *windowed_pleft  = (ftype *)s->windowed_prev->extended_data[0];
    
      ✗
          ftype *windowed_pright = (ftype *)s->windowed_prev->extended_data[1];
    
      ✗
          ftype *left_osamples   = (ftype *)out->extended_data[0];
    
      ✗
          ftype *right_osamples  = (ftype *)out->extended_data[1];
    
      ✗
          ftype *center_osamples = (ftype *)out->extended_data[2];
    
      ✗
          const int overlap = s->overlap;
    
      ✗
          const int offset = s->fft_size - overlap;
    
      ✗
          const int nb_samples = FFMIN(overlap, s->in->nb_samples);
    
          ftype vad;
    
          // shift in/out buffers
    
      ✗
          memmove(left_in, &left_in[overlap], offset * sizeof(ftype));
    
      ✗
          memmove(right_in, &right_in[overlap], offset * sizeof(ftype));
    
      ✗
          memmove(left_out, &left_out[overlap], offset * sizeof(ftype));
    
      ✗
          memmove(right_out, &right_out[overlap], offset * sizeof(ftype));
    
      ✗
          memcpy(&left_in[offset], left_samples, nb_samples * sizeof(ftype));
    
      ✗
          memcpy(&right_in[offset], right_samples, nb_samples * sizeof(ftype));
    
      ✗
          memset(&left_out[offset], 0, overlap * sizeof(ftype));
    
      ✗
          memset(&right_out[offset], 0, overlap * sizeof(ftype));
    
      ✗
          fn(apply_window)(s, left_in,  windowed_left,  0);
    
      ✗
          fn(apply_window)(s, right_in, windowed_right, 0);
    
      ✗
          s->tx_fn(s->tx_ctx[0], windowed_oleft,  windowed_left,  sizeof(ftype));
    
      ✗
          s->tx_fn(s->tx_ctx[1], windowed_oright, windowed_right, sizeof(ftype));
    
      ✗
          fn(get_centere)((ctype *)windowed_oleft,
    
                          (ctype *)windowed_oright,
    
                          (ctype *)center,
    
      ✗
                          s->fft_size / 2 + 1);
    
      ✗
          vad = fn(calc_vad)(fn(flux)(center, center_prev, s->fft_size / 2 + 1),
    
                             fn(fluxlr)(windowed_oleft, windowed_pleft,
    
      ✗
                                        windowed_oright, windowed_pright, s->fft_size / 2 + 1), s->voice);
    
      ✗
          vad = vad * 0.1 + 0.9 * fn(s->prev_vad);
    
      ✗
          fn(s->prev_vad) = vad;
    
      ✗
          memcpy(center_prev,     center,          s->fft_size * sizeof(ftype));
    
      ✗
          memcpy(windowed_pleft,  windowed_oleft,  s->fft_size * sizeof(ftype));
    
      ✗
          memcpy(windowed_pright, windowed_oright, s->fft_size * sizeof(ftype));
    
      ✗
          fn(get_final)(center, windowed_oleft, windowed_oright, vad, s->fft_size / 2 + 1,
    
      ✗
                        s->original, s->enhance);
    
      ✗
          s->itx_fn(s->itx_ctx, windowed_oleft, center, sizeof(ctype));
    
      ✗
          fn(apply_window)(s, windowed_oleft, left_out, 1);
    
      ✗
          memcpy(left_osamples, left_in, overlap * sizeof(ftype));
    
      ✗
          memcpy(right_osamples, right_in, overlap * sizeof(ftype));
    
      ✗
          if (ctx->is_disabled)
    
      ✗
              memset(center_osamples, 0, overlap * sizeof(ftype));
    
          else
    
      ✗
              memcpy(center_osamples, left_out, overlap * sizeof(ftype));
    
      ✗
          return 0;
    
      }

Line	Exec	Source
1		/*
2		* This file is part of FFmpeg.
3		*
4		* FFmpeg is free software; you can redistribute it and/or
5		* modify it under the terms of the GNU Lesser General Public
6		* License as published by the Free Software Foundation; either
7		* version 2.1 of the License, or (at your option) any later version.
8		*
9		* FFmpeg is distributed in the hope that it will be useful,
10		* but WITHOUT ANY WARRANTY; without even the implied warranty of
11		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12		* Lesser General Public License for more details.
13		*
14		* You should have received a copy of the GNU Lesser General Public
15		* License along with FFmpeg; if not, write to the Free Software
16		* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17		*/
18
19		#include "libavutil/mem.h"
20		#include "libavutil/tx.h"
21		#include "avfilter.h"
22		#include "internal.h"
23		#include "audio.h"
24
25		#undef ctype
26		#undef ftype
27		#undef SQRT
28		#undef HYPOT
29		#undef SAMPLE_FORMAT
30		#undef TX_TYPE
31		#undef ONE
32		#undef ZERO
33		#undef HALF
34		#undef SIN
35		#undef CLIP
36		#undef EPSILON
37		#if DEPTH == 32
38		#define SAMPLE_FORMAT float
39		#define SQRT sqrtf
40		#define HYPOT hypotf
41		#define ctype AVComplexFloat
42		#define ftype float
43		#define TX_TYPE AV_TX_FLOAT_RDFT
44		#define ONE 1.f
45		#define ZERO 0.f
46		#define HALF 0.5f
47		#define SIN sinf
48		#define CLIP av_clipf
49		#define EPSILON FLT_EPSILON
50		#else
51		#define SAMPLE_FORMAT double
52		#define SQRT sqrt
53		#define HYPOT hypot
54		#define ctype AVComplexDouble
55		#define ftype double
56		#define TX_TYPE AV_TX_DOUBLE_RDFT
57		#define ONE 1.0
58		#define ZERO 0.0
59		#define HALF 0.5
60		#define SIN sin
61		#define CLIP av_clipd
62		#define EPSILON DBL_EPSILON
63		#endif
64
65		#define fn3(a,b) a##_##b
66		#define fn2(a,b) fn3(a,b)
67		#define fn(a) fn2(a, SAMPLE_FORMAT)
68
69	✗	static int fn(de_tx_init)(AVFilterContext *ctx)
70		{
71	✗	AudioDialogueEnhanceContext *s = ctx->priv;
72	✗	ftype scale = ONE, iscale = ONE / (s->fft_size * 1.5f);
73		int ret;
74
75	✗	s->window = av_calloc(s->fft_size, sizeof(ftype));
76	✗	if (!s->window)
77	✗	return AVERROR(ENOMEM);
78	✗	fn(s->window) = s->window;
79	✗	for (int n = 0; n < s->fft_size; n++)
80	✗	fn(s->window)[n] = SIN(M_PI*n/(s->fft_size-1));
81
82	✗	ret = av_tx_init(&s->tx_ctx[0], &s->tx_fn, TX_TYPE, 0, s->fft_size, &scale, 0);
83	✗	if (ret < 0)
84	✗	return ret;
85
86	✗	ret = av_tx_init(&s->tx_ctx[1], &s->tx_fn, TX_TYPE, 0, s->fft_size, &scale, 0);
87	✗	if (ret < 0)
88	✗	return ret;
89
90	✗	ret = av_tx_init(&s->itx_ctx, &s->itx_fn, TX_TYPE, 1, s->fft_size, &iscale, 0);
91	✗	if (ret < 0)
92	✗	return ret;
93
94	✗	return 0;
95		}
96
97	✗	static void fn(apply_window)(AudioDialogueEnhanceContext *s,
98		const ftype in_frame, ftype out_frame, const int add_to_out_frame)
99		{
100	✗	const ftype *window = fn(s->window);
101	✗	const int fft_size = s->fft_size;
102
103	✗	if (add_to_out_frame) {
104	✗	for (int i = 0; i < fft_size; i++)
105	✗	out_frame[i] += in_frame[i] * window[i];
106		} else {
107	✗	for (int i = 0; i < fft_size; i++)
108	✗	out_frame[i] = in_frame[i] * window[i];
109		}
110	✗	}
111
112	✗	static ftype fn(sqr)(ftype x)
113		{
114	✗	return x * x;
115		}
116
117	✗	static void fn(get_centere)(ctype left, ctype right,
118		ctype *center, int N)
119		{
120	✗	for (int i = 0; i < N; i++) {
121	✗	const ftype l_re = left[i].re;
122	✗	const ftype l_im = left[i].im;
123	✗	const ftype r_re = right[i].re;
124	✗	const ftype r_im = right[i].im;
125	✗	const ftype a = HALF * (ONE - SQRT((fn(sqr)(l_re - r_re) + fn(sqr)(l_im - r_im))/
126	✗	(fn(sqr)(l_re + r_re) + fn(sqr)(l_im + r_im) + EPSILON)));
127
128	✗	center[i].re = a * (l_re + r_re);
129	✗	center[i].im = a * (l_im + r_im);
130		}
131	✗	}
132
133	✗	static ftype fn(flux)(ftype curf, ftype prevf, int N)
134		{
135	✗	ctype cur = (ctype )curf;
136	✗	ctype prev = (ctype )prevf;
137	✗	ftype sum = ZERO;
138
139	✗	for (int i = 0; i < N; i++) {
140	✗	ftype c_re = cur[i].re;
141	✗	ftype c_im = cur[i].im;
142	✗	ftype p_re = prev[i].re;
143	✗	ftype p_im = prev[i].im;
144
145	✗	sum += fn(sqr)(HYPOT(c_re, c_im) - HYPOT(p_re, p_im));
146		}
147
148	✗	return sum;
149		}
150
151	✗	static ftype fn(fluxlr)(ftype lf, ftype lpf,
152		ftype rf, ftype rpf,
153		int N)
154		{
155	✗	ctype l = (ctype )lf;
156	✗	ctype lp = (ctype )lpf;
157	✗	ctype r = (ctype )rf;
158	✗	ctype rp = (ctype )rpf;
159	✗	ftype sum = ZERO;
160
161	✗	for (int i = 0; i < N; i++) {
162	✗	ftype c_re = l[i].re - r[i].re;
163	✗	ftype c_im = l[i].im - r[i].im;
164	✗	ftype p_re = lp[i].re - rp[i].re;
165	✗	ftype p_im = lp[i].im - rp[i].im;
166
167	✗	sum += fn(sqr)(HYPOT(c_re, c_im) - HYPOT(p_re, p_im));
168		}
169
170	✗	return sum;
171		}
172
173	✗	static ftype fn(calc_vad)(ftype fc, ftype flr, ftype a)
174		{
175	✗	const ftype vad = a * (fc / (fc + flr) - HALF);
176
177	✗	return CLIP(vad, ZERO, ONE);
178		}
179
180	✗	static void fn(get_final)(ftype c, ftype l,
181		ftype *r, ftype vad, int N,
182		ftype original, ftype enhance)
183		{
184	✗	ctype center = (ctype )c;
185	✗	ctype left = (ctype )l;
186	✗	ctype right = (ctype )r;
187
188	✗	for (int i = 0; i < N; i++) {
189	✗	ftype cP = fn(sqr)(center[i].re) + fn(sqr)(center[i].im);
190	✗	ftype lrP = fn(sqr)(left[i].re - right[i].re) + fn(sqr)(left[i].im - right[i].im);
191	✗	ftype G = cP / (cP + lrP + EPSILON);
192		ftype re, im;
193
194	✗	re = center[i].re * (original + vad * G * enhance);
195	✗	im = center[i].im * (original + vad * G * enhance);
196
197	✗	center[i].re = re;
198	✗	center[i].im = im;
199		}
200	✗	}
201
202	✗	static int fn(de_stereo)(AVFilterContext ctx, AVFrame out)
203		{
204	✗	AudioDialogueEnhanceContext *s = ctx->priv;
205	✗	ftype center = (ftype )s->center_frame->extended_data[0];
206	✗	ftype center_prev = (ftype )s->center_frame->extended_data[1];
207	✗	ftype left_in = (ftype )s->in_frame->extended_data[0];
208	✗	ftype right_in = (ftype )s->in_frame->extended_data[1];
209	✗	ftype left_out = (ftype )s->out_dist_frame->extended_data[0];
210	✗	ftype right_out = (ftype )s->out_dist_frame->extended_data[1];
211	✗	ftype left_samples = (ftype )s->in->extended_data[0];
212	✗	ftype right_samples = (ftype )s->in->extended_data[1];
213	✗	ftype windowed_left = (ftype )s->windowed_frame->extended_data[0];
214	✗	ftype windowed_right = (ftype )s->windowed_frame->extended_data[1];
215	✗	ftype windowed_oleft = (ftype )s->windowed_out->extended_data[0];
216	✗	ftype windowed_oright = (ftype )s->windowed_out->extended_data[1];
217	✗	ftype windowed_pleft = (ftype )s->windowed_prev->extended_data[0];
218	✗	ftype windowed_pright = (ftype )s->windowed_prev->extended_data[1];
219	✗	ftype left_osamples = (ftype )out->extended_data[0];
220	✗	ftype right_osamples = (ftype )out->extended_data[1];
221	✗	ftype center_osamples = (ftype )out->extended_data[2];
222	✗	const int overlap = s->overlap;
223	✗	const int offset = s->fft_size - overlap;
224	✗	const int nb_samples = FFMIN(overlap, s->in->nb_samples);
225		ftype vad;
226
227		// shift in/out buffers
228	✗	memmove(left_in, &left_in[overlap], offset * sizeof(ftype));
229	✗	memmove(right_in, &right_in[overlap], offset * sizeof(ftype));
230	✗	memmove(left_out, &left_out[overlap], offset * sizeof(ftype));
231	✗	memmove(right_out, &right_out[overlap], offset * sizeof(ftype));
232
233	✗	memcpy(&left_in[offset], left_samples, nb_samples * sizeof(ftype));
234	✗	memcpy(&right_in[offset], right_samples, nb_samples * sizeof(ftype));
235	✗	memset(&left_out[offset], 0, overlap * sizeof(ftype));
236	✗	memset(&right_out[offset], 0, overlap * sizeof(ftype));
237
238	✗	fn(apply_window)(s, left_in, windowed_left, 0);
239	✗	fn(apply_window)(s, right_in, windowed_right, 0);
240
241	✗	s->tx_fn(s->tx_ctx[0], windowed_oleft, windowed_left, sizeof(ftype));
242	✗	s->tx_fn(s->tx_ctx[1], windowed_oright, windowed_right, sizeof(ftype));
243
244	✗	fn(get_centere)((ctype *)windowed_oleft,
245		(ctype *)windowed_oright,
246		(ctype *)center,
247	✗	s->fft_size / 2 + 1);
248
249	✗	vad = fn(calc_vad)(fn(flux)(center, center_prev, s->fft_size / 2 + 1),
250		fn(fluxlr)(windowed_oleft, windowed_pleft,
251	✗	windowed_oright, windowed_pright, s->fft_size / 2 + 1), s->voice);
252	✗	vad = vad * 0.1 + 0.9 * fn(s->prev_vad);
253	✗	fn(s->prev_vad) = vad;
254
255	✗	memcpy(center_prev, center, s->fft_size * sizeof(ftype));
256	✗	memcpy(windowed_pleft, windowed_oleft, s->fft_size * sizeof(ftype));
257	✗	memcpy(windowed_pright, windowed_oright, s->fft_size * sizeof(ftype));
258
259	✗	fn(get_final)(center, windowed_oleft, windowed_oright, vad, s->fft_size / 2 + 1,
260	✗	s->original, s->enhance);
261
262	✗	s->itx_fn(s->itx_ctx, windowed_oleft, center, sizeof(ctype));
263
264	✗	fn(apply_window)(s, windowed_oleft, left_out, 1);
265
266	✗	memcpy(left_osamples, left_in, overlap * sizeof(ftype));
267	✗	memcpy(right_osamples, right_in, overlap * sizeof(ftype));
268
269	✗	if (ctx->is_disabled)
270	✗	memset(center_osamples, 0, overlap * sizeof(ftype));
271		else
272	✗	memcpy(center_osamples, left_out, overlap * sizeof(ftype));
273
274	✗	return 0;
275		}
276

Function (Line)	Call count	Block coverage
apply_window_double (line 97)	not called	0.0%
apply_window_float (line 97)	not called	0.0%
calc_vad_double (line 173)	not called	0.0%
calc_vad_float (line 173)	not called	0.0%
de_tx_init_double (line 69)	not called	0.0%
de_tx_init_float (line 69)	not called	0.0%
flux_double (line 133)	not called	0.0%
flux_float (line 133)	not called	0.0%
fluxlr_double (line 151)	not called	0.0%
fluxlr_float (line 151)	not called	0.0%
get_centere_double (line 117)	not called	0.0%
get_centere_float (line 117)	not called	0.0%
get_final_double (line 180)	not called	0.0%
get_final_float (line 180)	not called	0.0%
sqr_double (line 112)	not called	0.0%
sqr_float (line 112)	not called	0.0%