大师用车|如何正确选择汽车脚垫我比你知道的 - 房山义和庄新闻网

Directory:	../../../ffmpeg/
File:	src/libavfilter/af_aecho.c
Date:	2025-08-04 00:43:16

	Exec	Total	Coverage
Lines:	106	138	76.8%
Functions:	9	12	75.0%
Branches:	56	117	47.9%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2013 Paul B Mahol
    
       *
    
       * 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/avassert.h"
    
      #include "libavutil/avstring.h"
    
      #include "libavutil/mem.h"
    
      #include "libavutil/opt.h"
    
      #include "libavutil/samplefmt.h"
    
      #include "avfilter.h"
    
      #include "audio.h"
    
      #include "filters.h"
    
      typedef struct AudioEchoContext {
    
          const AVClass *class;
    
          float in_gain, out_gain;
    
          char *delays, *decays;
    
          float *delay, *decay;
    
          int nb_echoes;
    
          int delay_index;
    
          uint8_t **delayptrs;
    
          int max_samples, fade_out;
    
          int *samples;
    
          int eof;
    
          int64_t next_pts;
    
          void (*echo_samples)(struct AudioEchoContext *ctx, uint8_t **delayptrs,
    
                               uint8_t * const *src, uint8_t **dst,
    
                               int nb_samples, int channels);
    
      } AudioEchoContext;
    
      #define OFFSET(x) offsetof(AudioEchoContext, x)
    
      #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
    
      static const AVOption aecho_options[] = {
    
          { "in_gain",  "set signal input gain",  OFFSET(in_gain),  AV_OPT_TYPE_FLOAT,  {.dbl=0.6}, 0, 1, A },
    
          { "out_gain", "set signal output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT,  {.dbl=0.3}, 0, 1, A },
    
          { "delays",   "set list of signal delays", OFFSET(delays), AV_OPT_TYPE_STRING, {.str="1000"}, 0, 0, A },
    
          { "decays",   "set list of signal decays", OFFSET(decays), AV_OPT_TYPE_STRING, {.str="0.5"}, 0, 0, A },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(aecho);
    
      4
      static void count_items(char *item_str, int *nb_items)
    
      {
    
          char *p;
    
      4
          *nb_items = 1;
    
        2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 4 times.

      14
          for (p = item_str; *p; p++) {
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.

      10
              if (*p == '|')
    
      ✗
                  (*nb_items)++;
    
          }
    
      4
      }
    
      4
      static void fill_items(char *item_str, int *nb_items, float *items)
    
      {
    
      4
          char *p, *saveptr = NULL;
    
      4
          int i, new_nb_items = 0;
    
      4
          p = item_str;
    
        2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.

      8
          for (i = 0; i < *nb_items; i++) {
    
      4
              char *tstr = av_strtok(p, "|", &saveptr);
    
      4
              p = NULL;
    
        1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

      4
              if (tstr)
    
      4
                  new_nb_items += av_sscanf(tstr, "%f", &items[new_nb_items]) == 1;
    
          }
    
      4
          *nb_items = new_nb_items;
    
      4
      }
    
      2
      static av_cold void uninit(AVFilterContext *ctx)
    
      {
    
      2
          AudioEchoContext *s = ctx->priv;
    
      2
          av_freep(&s->delay);
    
      2
          av_freep(&s->decay);
    
      2
          av_freep(&s->samples);
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.

      2
          if (s->delayptrs)
    
      1
              av_freep(&s->delayptrs[0]);
    
      2
          av_freep(&s->delayptrs);
    
      2
      }
    
      2
      static av_cold int init(AVFilterContext *ctx)
    
      {
    
      2
          AudioEchoContext *s = ctx->priv;
    
          int nb_delays, nb_decays, i;
    
        2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

      2
          if (!s->delays || !s->decays) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "Missing delays and/or decays.\n");
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      2
          count_items(s->delays, &nb_delays);
    
      2
          count_items(s->decays, &nb_decays);
    
      2
          s->delay = av_realloc_f(s->delay, nb_delays, sizeof(*s->delay));
    
      2
          s->decay = av_realloc_f(s->decay, nb_decays, sizeof(*s->decay));
    
        2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

      2
          if (!s->delay || !s->decay)
    
      ✗
              return AVERROR(ENOMEM);
    
      2
          fill_items(s->delays, &nb_delays, s->delay);
    
      2
          fill_items(s->decays, &nb_decays, s->decay);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          if (nb_delays != nb_decays) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "Number of delays %d differs from number of decays %d.\n", nb_delays, nb_decays);
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      2
          s->nb_echoes = nb_delays;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          if (!s->nb_echoes) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "At least one decay & delay must be set.\n");
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      2
          s->samples = av_realloc_f(s->samples, nb_delays, sizeof(*s->samples));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          if (!s->samples)
    
      ✗
              return AVERROR(ENOMEM);
    
        2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.

      4
          for (i = 0; i < nb_delays; i++) {
    
        2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

      2
              if (s->delay[i] <= 0 || s->delay[i] > 90000) {
    
      ✗
                  av_log(ctx, AV_LOG_ERROR, "delay[%d]: %f is out of allowed range: (0, 90000]\n", i, s->delay[i]);
    
      ✗
                  return AVERROR(EINVAL);
    
              }
    
        2/4✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

      2
              if (s->decay[i] <= 0 || s->decay[i] > 1) {
    
      ✗
                  av_log(ctx, AV_LOG_ERROR, "decay[%d]: %f is out of allowed range: (0, 1]\n", i, s->decay[i]);
    
      ✗
                  return AVERROR(EINVAL);
    
              }
    
          }
    
      2
          s->next_pts = AV_NOPTS_VALUE;
    
      2
          av_log(ctx, AV_LOG_DEBUG, "nb_echoes:%d\n", s->nb_echoes);
    
      2
          return 0;
    
      }
    
      #define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
    
      #define ECHO(name, type, min, max)                                          \
    
      static void echo_samples_## name ##p(AudioEchoContext *ctx,                 \
    
                                           uint8_t **delayptrs,                   \
    
                                           uint8_t * const *src, uint8_t **dst,   \
    
                                           int nb_samples, int channels)          \
    
      {                                                                           \
    
          const double out_gain = ctx->out_gain;                                  \
    
          const double in_gain = ctx->in_gain;                                    \
    
          const int nb_echoes = ctx->nb_echoes;                                   \
    
          const int max_samples = ctx->max_samples;                               \
    
          int i, j, chan, av_uninit(index);                                       \
    
                                                                                  \
    
          av_assert1(channels > 0); /* would corrupt delay_index */               \
    
                                                                                  \
    
          for (chan = 0; chan < channels; chan++) {                               \
    
              const type *s = (type *)src[chan];                                  \
    
              type *d = (type *)dst[chan];                                        \
    
              type *dbuf = (type *)delayptrs[chan];                               \
    
                                                                                  \
    
              index = ctx->delay_index;                                           \
    
              for (i = 0; i < nb_samples; i++, s++, d++) {                        \
    
                  double out, in;                                                 \
    
                                                                                  \
    
                  in = *s;                                                        \
    
                  out = in * in_gain;                                             \
    
                  for (j = 0; j < nb_echoes; j++) {                               \
    
                      int ix = index + max_samples - ctx->samples[j];             \
    
                      ix = MOD(ix, max_samples);                                  \
    
                      out += dbuf[ix] * ctx->decay[j];                            \
    
                  }                                                               \
    
                  out *= out_gain;                                                \
    
                                                                                  \
    
                  *d = av_clipd(out, min, max);                                   \
    
                  dbuf[index] = in;                                               \
    
                                                                                  \
    
                  index = MOD(index + 1, max_samples);                            \
    
              }                                                                   \
    
          }                                                                       \
    
          ctx->delay_index = index;                                               \
    
      }
    
      ✗
      ECHO(dbl, double,  -1.0,      1.0      )
    
      ✗
      ECHO(flt, float,   -1.0,      1.0      )
    
        9/10✗ Branch 0 not taken.
✓ Branch 1 taken 532022 times.
✓ Branch 2 taken 532022 times.
✓ Branch 3 taken 532022 times.
✓ Branch 4 taken 376 times.
✓ Branch 5 taken 531646 times.
✓ Branch 6 taken 532022 times.
✓ Branch 7 taken 132 times.
✓ Branch 8 taken 132 times.
✓ Branch 9 taken 66 times.

      1064242
      ECHO(s16, int16_t, INT16_MIN, INT16_MAX)
    
      ✗
      ECHO(s32, int32_t, INT32_MIN, INT32_MAX)
    
      1
      static int config_output(AVFilterLink *outlink)
    
      {
    
      1
          AVFilterContext *ctx = outlink->src;
    
      1
          AudioEchoContext *s = ctx->priv;
    
      1
          float volume = 1.0;
    
          int i;
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.

      2
          for (i = 0; i < s->nb_echoes; i++) {
    
      1
              s->samples[i] = s->delay[i] * outlink->sample_rate / 1000.0;
    
      1
              s->max_samples = FFMAX(s->max_samples, s->samples[i]);
    
      1
              volume += s->decay[i];
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (s->max_samples <= 0) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "Nothing to echo - missing delay samples.\n");
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      1
          s->fade_out = s->max_samples;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (volume * s->in_gain * s->out_gain > 1.0)
    
      ✗
              av_log(ctx, AV_LOG_WARNING,
    
      ✗
                     "out_gain %f can cause saturation of output\n", s->out_gain);
    
        1/5✗ Branch 0 not taken.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

      1
          switch (outlink->format) {
    
      ✗
          case AV_SAMPLE_FMT_DBLP: s->echo_samples = echo_samples_dblp; break;
    
      ✗
          case AV_SAMPLE_FMT_FLTP: s->echo_samples = echo_samples_fltp; break;
    
      1
          case AV_SAMPLE_FMT_S16P: s->echo_samples = echo_samples_s16p; break;
    
      ✗
          case AV_SAMPLE_FMT_S32P: s->echo_samples = echo_samples_s32p; break;
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (s->delayptrs)
    
      ✗
              av_freep(&s->delayptrs[0]);
    
      1
          av_freep(&s->delayptrs);
    
      1
          return av_samples_alloc_array_and_samples(&s->delayptrs, NULL,
    
                                                    outlink->ch_layout.nb_channels,
    
                                                    s->max_samples,
    
      1
                                                    outlink->format, 0);
    
      }
    
      65
      static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
    
      {
    
      65
          AVFilterContext *ctx = inlink->dst;
    
      65
          AudioEchoContext *s = ctx->priv;
    
          AVFrame *out_frame;
    
        1/2✓ Branch 1 taken 65 times.
✗ Branch 2 not taken.

      65
          if (av_frame_is_writable(frame)) {
    
      65
              out_frame = frame;
    
          } else {
    
      ✗
              out_frame = ff_get_audio_buffer(ctx->outputs[0], frame->nb_samples);
    
      ✗
              if (!out_frame) {
    
      ✗
                  av_frame_free(&frame);
    
      ✗
                  return AVERROR(ENOMEM);
    
              }
    
      ✗
              av_frame_copy_props(out_frame, frame);
    
          }
    
      65
          s->echo_samples(s, s->delayptrs, frame->extended_data, out_frame->extended_data,
    
      65
                          frame->nb_samples, inlink->ch_layout.nb_channels);
    
      65
          s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.

      65
          if (frame != out_frame)
    
      ✗
              av_frame_free(&frame);
    
      65
          return ff_filter_frame(ctx->outputs[0], out_frame);
    
      }
    
      1
      static int request_frame(AVFilterLink *outlink)
    
      {
    
      1
          AVFilterContext *ctx = outlink->src;
    
      1
          AudioEchoContext *s = ctx->priv;
    
      1
          int nb_samples = FFMIN(s->fade_out, 2048);
    
      1
          AVFrame *frame = ff_get_audio_buffer(outlink, nb_samples);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (!frame)
    
      ✗
              return AVERROR(ENOMEM);
    
      1
          s->fade_out -= nb_samples;
    
      1
          av_samples_set_silence(frame->extended_data, 0,
    
                                 frame->nb_samples,
    
                                 outlink->ch_layout.nb_channels,
    
      1
                                 frame->format);
    
      1
          s->echo_samples(s, s->delayptrs, frame->extended_data, frame->extended_data,
    
                          frame->nb_samples, outlink->ch_layout.nb_channels);
    
      1
          frame->pts = s->next_pts;
    
        1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.

      1
          if (s->next_pts != AV_NOPTS_VALUE)
    
      1
              s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
    
      1
          return ff_filter_frame(outlink, frame);
    
      }
    
      132
      static int activate(AVFilterContext *ctx)
    
      {
    
      132
          AVFilterLink *inlink = ctx->inputs[0];
    
      132
          AVFilterLink *outlink = ctx->outputs[0];
    
      132
          AudioEchoContext *s = ctx->priv;
    
          AVFrame *in;
    
          int ret, status;
    
          int64_t pts;
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 132 times.

      132
          FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
    
      132
          ret = ff_inlink_consume_frame(inlink, &in);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 132 times.

      132
          if (ret < 0)
    
      ✗
              return ret;
    
        2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 67 times.

      132
          if (ret > 0)
    
      65
              return filter_frame(inlink, in);
    
        4/4✓ Branch 0 taken 66 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 65 times.

      67
          if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
    
        1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.

      1
              if (status == AVERROR_EOF)
    
      1
                  s->eof = 1;
    
          }
    
        4/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.

      67
          if (s->eof && s->fade_out <= 0) {
    
      1
              ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
    
      1
              return 0;
    
          }
    
        2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 1 times.

      66
          if (!s->eof)
    
        1/2✓ Branch 1 taken 65 times.
✗ Branch 2 not taken.

      65
              FF_FILTER_FORWARD_WANTED(outlink, inlink);
    
      1
          return request_frame(outlink);
    
      }
    
      static const AVFilterPad aecho_outputs[] = {
    
          {
    
              .name          = "default",
    
              .config_props  = config_output,
    
              .type          = AVMEDIA_TYPE_AUDIO,
    
          },
    
      };
    
      const FFFilter ff_af_aecho = {
    
          .p.name        = "aecho",
    
          .p.description = NULL_IF_CONFIG_SMALL("Add echoing to the audio."),
    
          .p.priv_class  = &aecho_class,
    
          .priv_size     = sizeof(AudioEchoContext),
    
          .init          = init,
    
          .activate      = activate,
    
          .uninit        = uninit,
    
          FILTER_INPUTS(ff_audio_default_filterpad),
    
          FILTER_OUTPUTS(aecho_outputs),
    
          FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
    
                            AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP),
    
      };

做小吃什么生意最赚钱	怕冷的人是什么原因	蔬菜沙拉都放什么菜	白细胞低是什么意思	同位素是什么
多汗症是什么原因引起的	心悸失眠是什么症状	长期失眠吃什么药	鮰鱼是什么鱼	残疾证有什么补贴
黄褐斑是什么样的图片	药娘吃的什么药	左眼皮老跳是什么原因	飞蛾飞进家里预示什么	28度穿什么衣服合适
神经性头疼是什么症状	一闪一闪的星星像什么	美女什么都没有穿	seconds是什么意思	桃皮绒是什么面料

湖南什么山最出名xinmaowt.com	相害是什么意思hcv7jop5ns2r.cn	女人戴什么手串辟邪hcv8jop8ns3r.cn	是否是什么意思hcv8jop6ns0r.cn	鼻子突然流血是什么原因hcv8jop5ns2r.cn
蛇盘疮吃什么药hcv8jop6ns8r.cn	女性外阴痒用什么药hcv8jop9ns1r.cn	邓超什么星座的hcv9jop4ns5r.cn	终身为国是什么生肖hcv9jop1ns5r.cn	皮脂膜是什么hcv9jop3ns6r.cn
什么叫同人文hcv8jop7ns2r.cn	什么是网恋hcv8jop2ns5r.cn	为什么说啄木鸟是树的医生hcv7jop5ns3r.cn	面色晄白是什么意思hcv9jop0ns0r.cn	破釜沉舟是什么意思hcv8jop1ns1r.cn
灰指甲是什么原因引起的hcv8jop1ns9r.cn	钾低会出现什么症状hcv8jop8ns7r.cn	斯夫是什么意思naasee.com	相逢是什么意思hcv9jop6ns9r.cn	旅长是什么级别hcv8jop5ns8r.cn

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2013 Paul B Mahol
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#include "libavutil/avassert.h"
22			#include "libavutil/avstring.h"
23			#include "libavutil/mem.h"
24			#include "libavutil/opt.h"
25			#include "libavutil/samplefmt.h"
26			#include "avfilter.h"
27			#include "audio.h"
28			#include "filters.h"
29
30			typedef struct AudioEchoContext {
31			const AVClass *class;
32			float in_gain, out_gain;
33			char delays, decays;
34			float delay, decay;
35			int nb_echoes;
36			int delay_index;
37			uint8_t **delayptrs;
38			int max_samples, fade_out;
39			int *samples;
40			int eof;
41			int64_t next_pts;
42
43			void (echo_samples)(struct AudioEchoContext ctx, uint8_t **delayptrs,
44			uint8_t * const src, uint8_t *dst,
45			int nb_samples, int channels);
46			} AudioEchoContext;
47
48			#define OFFSET(x) offsetof(AudioEchoContext, x)
49			#define A AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
50
51			static const AVOption aecho_options[] = {
52			{ "in_gain", "set signal input gain", OFFSET(in_gain), AV_OPT_TYPE_FLOAT, {.dbl=0.6}, 0, 1, A },
53			{ "out_gain", "set signal output gain", OFFSET(out_gain), AV_OPT_TYPE_FLOAT, {.dbl=0.3}, 0, 1, A },
54			{ "delays", "set list of signal delays", OFFSET(delays), AV_OPT_TYPE_STRING, {.str="1000"}, 0, 0, A },
55			{ "decays", "set list of signal decays", OFFSET(decays), AV_OPT_TYPE_STRING, {.str="0.5"}, 0, 0, A },
56			{ NULL }
57			};
58
59			AVFILTER_DEFINE_CLASS(aecho);
60
61		4	static void count_items(char item_str, int nb_items)
62			{
63			char *p;
64
65		4	*nb_items = 1;
66	2/2 ✓ Branch 0 taken 10 times. ✓ Branch 1 taken 4 times.	14	for (p = item_str; *p; p++) {
67	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 10 times.	10	if (*p == '\|')
68		✗	(*nb_items)++;
69			}
70
71		4	}
72
73		4	static void fill_items(char item_str, int nb_items, float *items)
74			{
75		4	char p, saveptr = NULL;
76		4	int i, new_nb_items = 0;
77
78		4	p = item_str;
79	2/2 ✓ Branch 0 taken 4 times. ✓ Branch 1 taken 4 times.	8	for (i = 0; i < *nb_items; i++) {
80		4	char *tstr = av_strtok(p, "\|", &saveptr);
81		4	p = NULL;
82	1/2 ✓ Branch 0 taken 4 times. ✗ Branch 1 not taken.	4	if (tstr)
83		4	new_nb_items += av_sscanf(tstr, "%f", &items[new_nb_items]) == 1;
84			}
85
86		4	*nb_items = new_nb_items;
87		4	}
88
89		2	static av_cold void uninit(AVFilterContext *ctx)
90			{
91		2	AudioEchoContext *s = ctx->priv;
92
93		2	av_freep(&s->delay);
94		2	av_freep(&s->decay);
95		2	av_freep(&s->samples);
96
97	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 1 times.	2	if (s->delayptrs)
98		1	av_freep(&s->delayptrs[0]);
99		2	av_freep(&s->delayptrs);
100		2	}
101
102		2	static av_cold int init(AVFilterContext *ctx)
103			{
104		2	AudioEchoContext *s = ctx->priv;
105			int nb_delays, nb_decays, i;
106
107	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times.	2	if (!s->delays \|\| !s->decays) {
108		✗	av_log(ctx, AV_LOG_ERROR, "Missing delays and/or decays.\n");
109		✗	return AVERROR(EINVAL);
110			}
111
112		2	count_items(s->delays, &nb_delays);
113		2	count_items(s->decays, &nb_decays);
114
115		2	s->delay = av_realloc_f(s->delay, nb_delays, sizeof(*s->delay));
116		2	s->decay = av_realloc_f(s->decay, nb_decays, sizeof(*s->decay));
117	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times.	2	if (!s->delay \|\| !s->decay)
118		✗	return AVERROR(ENOMEM);
119
120		2	fill_items(s->delays, &nb_delays, s->delay);
121		2	fill_items(s->decays, &nb_decays, s->decay);
122
123	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2	if (nb_delays != nb_decays) {
124		✗	av_log(ctx, AV_LOG_ERROR, "Number of delays %d differs from number of decays %d.\n", nb_delays, nb_decays);
125		✗	return AVERROR(EINVAL);
126			}
127
128		2	s->nb_echoes = nb_delays;
129	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2	if (!s->nb_echoes) {
130		✗	av_log(ctx, AV_LOG_ERROR, "At least one decay & delay must be set.\n");
131		✗	return AVERROR(EINVAL);
132			}
133
134		2	s->samples = av_realloc_f(s->samples, nb_delays, sizeof(*s->samples));
135	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2	if (!s->samples)
136		✗	return AVERROR(ENOMEM);
137
138	2/2 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 2 times.	4	for (i = 0; i < nb_delays; i++) {
139	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times.	2	if (s->delay[i] <= 0 \|\| s->delay[i] > 90000) {
140		✗	av_log(ctx, AV_LOG_ERROR, "delay[%d]: %f is out of allowed range: (0, 90000]\n", i, s->delay[i]);
141		✗	return AVERROR(EINVAL);
142			}
143	2/4 ✓ Branch 0 taken 2 times. ✗ Branch 1 not taken. ✗ Branch 2 not taken. ✓ Branch 3 taken 2 times.	2	if (s->decay[i] <= 0 \|\| s->decay[i] > 1) {
144		✗	av_log(ctx, AV_LOG_ERROR, "decay[%d]: %f is out of allowed range: (0, 1]\n", i, s->decay[i]);
145		✗	return AVERROR(EINVAL);
146			}
147			}
148
149		2	s->next_pts = AV_NOPTS_VALUE;
150
151		2	av_log(ctx, AV_LOG_DEBUG, "nb_echoes:%d\n", s->nb_echoes);
152		2	return 0;
153			}
154
155			#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))
156
157			#define ECHO(name, type, min, max) \
158			static void echo_samples_## name ##p(AudioEchoContext *ctx, \
159			uint8_t **delayptrs, \
160			uint8_t * const src, uint8_t *dst, \
161			int nb_samples, int channels) \
162			{ \
163			const double out_gain = ctx->out_gain; \
164			const double in_gain = ctx->in_gain; \
165			const int nb_echoes = ctx->nb_echoes; \
166			const int max_samples = ctx->max_samples; \
167			int i, j, chan, av_uninit(index); \
168			\
169			av_assert1(channels > 0); /* would corrupt delay_index */ \
170			\
171			for (chan = 0; chan < channels; chan++) { \
172			const type s = (type )src[chan]; \
173			type d = (type )dst[chan]; \
174			type dbuf = (type )delayptrs[chan]; \
175			\
176			index = ctx->delay_index; \
177			for (i = 0; i < nb_samples; i++, s++, d++) { \
178			double out, in; \
179			\
180			in = *s; \
181			out = in * in_gain; \
182			for (j = 0; j < nb_echoes; j++) { \
183			int ix = index + max_samples - ctx->samples[j]; \
184			ix = MOD(ix, max_samples); \
185			out += dbuf[ix] * ctx->decay[j]; \
186			} \
187			out *= out_gain; \
188			\
189			*d = av_clipd(out, min, max); \
190			dbuf[index] = in; \
191			\
192			index = MOD(index + 1, max_samples); \
193			} \
194			} \
195			ctx->delay_index = index; \
196			}
197
198		✗	ECHO(dbl, double, -1.0, 1.0 )
199		✗	ECHO(flt, float, -1.0, 1.0 )
200	9/10 ✗ Branch 0 not taken. ✓ Branch 1 taken 532022 times. ✓ Branch 2 taken 532022 times. ✓ Branch 3 taken 532022 times. ✓ Branch 4 taken 376 times. ✓ Branch 5 taken 531646 times. ✓ Branch 6 taken 532022 times. ✓ Branch 7 taken 132 times. ✓ Branch 8 taken 132 times. ✓ Branch 9 taken 66 times.	1064242	ECHO(s16, int16_t, INT16_MIN, INT16_MAX)
201		✗	ECHO(s32, int32_t, INT32_MIN, INT32_MAX)
202
203		1	static int config_output(AVFilterLink *outlink)
204			{
205		1	AVFilterContext *ctx = outlink->src;
206		1	AudioEchoContext *s = ctx->priv;
207		1	float volume = 1.0;
208			int i;
209
210	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 1 times.	2	for (i = 0; i < s->nb_echoes; i++) {
211		1	s->samples[i] = s->delay[i] * outlink->sample_rate / 1000.0;
212		1	s->max_samples = FFMAX(s->max_samples, s->samples[i]);
213		1	volume += s->decay[i];
214			}
215
216	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (s->max_samples <= 0) {
217		✗	av_log(ctx, AV_LOG_ERROR, "Nothing to echo - missing delay samples.\n");
218		✗	return AVERROR(EINVAL);
219			}
220		1	s->fade_out = s->max_samples;
221
222	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (volume * s->in_gain * s->out_gain > 1.0)
223		✗	av_log(ctx, AV_LOG_WARNING,
224		✗	"out_gain %f can cause saturation of output\n", s->out_gain);
225
226	1/5 ✗ Branch 0 not taken. ✗ Branch 1 not taken. ✓ Branch 2 taken 1 times. ✗ Branch 3 not taken. ✗ Branch 4 not taken.	1	switch (outlink->format) {
227		✗	case AV_SAMPLE_FMT_DBLP: s->echo_samples = echo_samples_dblp; break;
228		✗	case AV_SAMPLE_FMT_FLTP: s->echo_samples = echo_samples_fltp; break;
229		1	case AV_SAMPLE_FMT_S16P: s->echo_samples = echo_samples_s16p; break;
230		✗	case AV_SAMPLE_FMT_S32P: s->echo_samples = echo_samples_s32p; break;
231			}
232
233
234	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (s->delayptrs)
235		✗	av_freep(&s->delayptrs[0]);
236		1	av_freep(&s->delayptrs);
237
238		1	return av_samples_alloc_array_and_samples(&s->delayptrs, NULL,
239			outlink->ch_layout.nb_channels,
240			s->max_samples,
241		1	outlink->format, 0);
242			}
243
244		65	static int filter_frame(AVFilterLink inlink, AVFrame frame)
245			{
246		65	AVFilterContext *ctx = inlink->dst;
247		65	AudioEchoContext *s = ctx->priv;
248			AVFrame *out_frame;
249
250	1/2 ✓ Branch 1 taken 65 times. ✗ Branch 2 not taken.	65	if (av_frame_is_writable(frame)) {
251		65	out_frame = frame;
252			} else {
253		✗	out_frame = ff_get_audio_buffer(ctx->outputs[0], frame->nb_samples);
254		✗	if (!out_frame) {
255		✗	av_frame_free(&frame);
256		✗	return AVERROR(ENOMEM);
257			}
258		✗	av_frame_copy_props(out_frame, frame);
259			}
260
261		65	s->echo_samples(s, s->delayptrs, frame->extended_data, out_frame->extended_data,
262		65	frame->nb_samples, inlink->ch_layout.nb_channels);
263
264		65	s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
265
266	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 65 times.	65	if (frame != out_frame)
267		✗	av_frame_free(&frame);
268
269		65	return ff_filter_frame(ctx->outputs[0], out_frame);
270			}
271
272		1	static int request_frame(AVFilterLink *outlink)
273			{
274		1	AVFilterContext *ctx = outlink->src;
275		1	AudioEchoContext *s = ctx->priv;
276		1	int nb_samples = FFMIN(s->fade_out, 2048);
277		1	AVFrame *frame = ff_get_audio_buffer(outlink, nb_samples);
278
279	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (!frame)
280		✗	return AVERROR(ENOMEM);
281		1	s->fade_out -= nb_samples;
282
283		1	av_samples_set_silence(frame->extended_data, 0,
284			frame->nb_samples,
285			outlink->ch_layout.nb_channels,
286		1	frame->format);
287
288		1	s->echo_samples(s, s->delayptrs, frame->extended_data, frame->extended_data,
289			frame->nb_samples, outlink->ch_layout.nb_channels);
290
291		1	frame->pts = s->next_pts;
292	1/2 ✓ Branch 0 taken 1 times. ✗ Branch 1 not taken.	1	if (s->next_pts != AV_NOPTS_VALUE)
293		1	s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base);
294
295		1	return ff_filter_frame(outlink, frame);
296			}
297
298		132	static int activate(AVFilterContext *ctx)
299			{
300		132	AVFilterLink *inlink = ctx->inputs[0];
301		132	AVFilterLink *outlink = ctx->outputs[0];
302		132	AudioEchoContext *s = ctx->priv;
303			AVFrame *in;
304			int ret, status;
305			int64_t pts;
306
307	1/2 ✗ Branch 1 not taken. ✓ Branch 2 taken 132 times.	132	FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
308
309		132	ret = ff_inlink_consume_frame(inlink, &in);
310	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 132 times.	132	if (ret < 0)
311		✗	return ret;
312	2/2 ✓ Branch 0 taken 65 times. ✓ Branch 1 taken 67 times.	132	if (ret > 0)
313		65	return filter_frame(inlink, in);
314
315	4/4 ✓ Branch 0 taken 66 times. ✓ Branch 1 taken 1 times. ✓ Branch 3 taken 1 times. ✓ Branch 4 taken 65 times.	67	if (!s->eof && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
316	1/2 ✓ Branch 0 taken 1 times. ✗ Branch 1 not taken.	1	if (status == AVERROR_EOF)
317		1	s->eof = 1;
318			}
319
320	4/4 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 65 times. ✓ Branch 2 taken 1 times. ✓ Branch 3 taken 1 times.	67	if (s->eof && s->fade_out <= 0) {
321		1	ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
322		1	return 0;
323			}
324
325	2/2 ✓ Branch 0 taken 65 times. ✓ Branch 1 taken 1 times.	66	if (!s->eof)
326	1/2 ✓ Branch 1 taken 65 times. ✗ Branch 2 not taken.	65	FF_FILTER_FORWARD_WANTED(outlink, inlink);
327
328		1	return request_frame(outlink);
329			}
330
331			static const AVFilterPad aecho_outputs[] = {
332			{
333			.name = "default",
334			.config_props = config_output,
335			.type = AVMEDIA_TYPE_AUDIO,
336			},
337			};
338
339			const FFFilter ff_af_aecho = {
340			.p.name = "aecho",
341			.p.description = NULL_IF_CONFIG_SMALL("Add echoing to the audio."),
342			.p.priv_class = &aecho_class,
343			.priv_size = sizeof(AudioEchoContext),
344			.init = init,
345			.activate = activate,
346			.uninit = uninit,
347			FILTER_INPUTS(ff_audio_default_filterpad),
348			FILTER_OUTPUTS(aecho_outputs),
349			FILTER_SAMPLEFMTS(AV_SAMPLE_FMT_S16P, AV_SAMPLE_FMT_S32P,
350			AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP),
351			};
352

Function (Line)	Call count	Block coverage
activate (line 298)	called 132 times, returned 132 times	89.0%
config_output (line 203)	called 1 time, returned 1 time	61.0%
count_items (line 61)	called 4 times, returned 4 times	83.0%
echo_samples_dblp (line 198)	not called	0.0%
echo_samples_fltp (line 199)	not called	0.0%
echo_samples_s16p (line 200)	called 66 times, returned 66 times	94.0%
echo_samples_s32p (line 201)	not called	0.0%
fill_items (line 73)	called 4 times, returned 4 times	100.0%
filter_frame (line 244)	called 65 times, returned 65 times	57.0%
init (line 102)	called 2 times, returned 2 times	68.0%
request_frame (line 272)	called 1 time, returned 1 time	89.0%
uninit (line 89)	called 2 times, returned 2 times	100.0%