哪台车型最优秀全球汽车媒体人给出了标准答案

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

	Exec	Total	Coverage
Lines:	62	72	86.1%
Functions:	5	5	100.0%
Branches:	29	50	58.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2012 Michael Niedermayer
    
       *
    
       * 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
    
       */
    
      /**
    
       * @file
    
       * audio pad filter.
    
       *
    
       * Based on af_aresample.c
    
       */
    
      #include "libavutil/avstring.h"
    
      #include "libavutil/channel_layout.h"
    
      #include "libavutil/opt.h"
    
      #include "libavutil/samplefmt.h"
    
      #include "libavutil/avassert.h"
    
      #include "avfilter.h"
    
      #include "audio.h"
    
      #include "filters.h"
    
      typedef struct APadContext {
    
          const AVClass *class;
    
          int64_t next_pts;
    
          int eof;
    
          int packet_size;
    
          int64_t pad_len, pad_len_left;
    
          int64_t whole_len, whole_len_left;
    
          int64_t pad_dur;
    
          int64_t whole_dur;
    
      } APadContext;
    
      #define OFFSET(x) offsetof(APadContext, x)
    
      #define A AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
    
      static const AVOption apad_options[] = {
    
          { "packet_size", "set silence packet size",                                  OFFSET(packet_size), AV_OPT_TYPE_INT,   { .i64 = 4096 }, 0, INT_MAX, A },
    
          { "pad_len",     "set number of samples of silence to add",                  OFFSET(pad_len),     AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, A },
    
          { "whole_len",   "set minimum target number of samples in the audio stream", OFFSET(whole_len),   AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, A },
    
          { "pad_dur",     "set duration of silence to add",                           OFFSET(pad_dur),     AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, A },
    
          { "whole_dur",   "set minimum target duration in the audio stream",          OFFSET(whole_dur),   AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, A },
    
          { NULL }
    
      };
    
      AVFILTER_DEFINE_CLASS(apad);
    
      2
      static av_cold int init(AVFilterContext *ctx)
    
      {
    
      2
          APadContext *s = ctx->priv;
    
      2
          s->next_pts = AV_NOPTS_VALUE;
    
        1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

      2
          if (s->whole_len >= 0 && s->pad_len >= 0) {
    
      ✗
              av_log(ctx, AV_LOG_ERROR, "Both whole and pad length are set, this is not possible\n");
    
      ✗
              return AVERROR(EINVAL);
    
          }
    
      2
          return 0;
    
      }
    
      65
      static int filter_frame(AVFilterLink *inlink, AVFrame *frame)
    
      {
    
      65
          AVFilterContext *ctx = inlink->dst;
    
      65
          APadContext *s = ctx->priv;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.

      65
          if (s->whole_len >= 0) {
    
      ✗
              s->whole_len_left = FFMAX(s->whole_len_left - frame->nb_samples, 0);
    
      ✗
              av_log(ctx, AV_LOG_DEBUG,
    
                     "n_out:%d whole_len_left:%"PRId64"\n", frame->nb_samples, s->whole_len_left);
    
          }
    
      65
          s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
    
      65
          return ff_filter_frame(ctx->outputs[0], frame);
    
      }
    
      2
      static int push_frame(AVFilterLink *outlink)
    
      {
    
      2
          AVFilterContext *ctx = outlink->src;
    
      2
          APadContext *s = ctx->priv;
    
          AVFrame *outsamplesref;
    
          int n_out;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

      2
          if (ctx->is_disabled)
    
      ✗
              return 0;
    
      2
          n_out = s->packet_size;
    
        1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

      2
          if (s->whole_len >= 0 && s->pad_len < 0) {
    
      ✗
              s->pad_len = s->pad_len_left = s->whole_len_left;
    
          }
    
        1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

      2
          if (s->pad_len >=0 || s->whole_len >= 0) {
    
      2
              n_out = FFMIN(n_out, s->pad_len_left);
    
      2
              s->pad_len_left -= n_out;
    
      2
              av_log(ctx, AV_LOG_DEBUG,
    
                     "padding n_out:%d pad_len_left:%"PRId64"\n", n_out, s->pad_len_left);
    
          }
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.

      2
          if (!n_out)
    
      1
              return AVERROR_EOF;
    
      1
          outsamplesref = ff_get_audio_buffer(outlink, n_out);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (!outsamplesref)
    
      ✗
              return AVERROR(ENOMEM);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          av_assert0(outsamplesref->sample_rate == outlink->sample_rate);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          av_assert0(outsamplesref->nb_samples  == n_out);
    
      1
          av_samples_set_silence(outsamplesref->extended_data, 0,
    
                                 n_out,
    
                                 outsamplesref->ch_layout.nb_channels,
    
      1
                                 outsamplesref->format);
    
      1
          outsamplesref->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(n_out, (AVRational){1, outlink->sample_rate}, outlink->time_base);
    
      1
          return ff_filter_frame(outlink, outsamplesref);
    
      }
    
      132
      static int activate(AVFilterContext *ctx)
    
      {
    
      132
          AVFilterLink *inlink = ctx->inputs[0];
    
      132
          AVFilterLink *outlink = ctx->outputs[0];
    
      132
          APadContext *s = ctx->priv;
    
          int64_t pts;
    
          int status;
    
        1/2✗ Branch 1 not taken.
✓ Branch 2 taken 132 times.

      132
          FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
    
        4/4✓ Branch 0 taken 131 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 65 times.
✓ Branch 4 taken 66 times.

      132
          if (!s->eof && ff_inlink_queued_frames(inlink)) {
    
      65
              AVFrame *frame = NULL;
    
              int ret;
    
      65
              ret = ff_inlink_consume_frame(inlink, &frame);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 65 times.

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

      65
              if (ret > 0)
    
      65
                  return filter_frame(inlink, frame);
    
          }
    
        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
              s->eof = status == AVERROR_EOF;
    
        2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 65 times.

      67
          if (s->eof) {
    
      2
              int ret = push_frame(outlink);
    
        2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.

      2
              if (ret == AVERROR_EOF) {
    
      1
                  ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
    
      1
                  return 0;
    
              }
    
      1
              return ret;
    
          }
    
        1/2✓ Branch 1 taken 65 times.
✗ Branch 2 not taken.

      65
          FF_FILTER_FORWARD_WANTED(outlink, inlink);
    
      ✗
          return FFERROR_NOT_READY;
    
      }
    
      1
      static int config_output(AVFilterLink *outlink)
    
      {
    
      1
          AVFilterContext *ctx = outlink->src;
    
      1
          APadContext *s  = ctx->priv;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (s->pad_dur >= 0)
    
      ✗
              s->pad_len = av_rescale(s->pad_dur, outlink->sample_rate, AV_TIME_BASE);
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.

      1
          if (s->whole_dur >= 0)
    
      ✗
              s->whole_len = av_rescale(s->whole_dur, outlink->sample_rate, AV_TIME_BASE);
    
      1
          s->pad_len_left   = s->pad_len;
    
      1
          s->whole_len_left = s->whole_len;
    
      1
          return 0;
    
      }
    
      static const AVFilterPad apad_outputs[] = {
    
          {
    
              .name          = "default",
    
              .type          = AVMEDIA_TYPE_AUDIO,
    
              .config_props  = config_output,
    
          },
    
      };
    
      const FFFilter ff_af_apad = {
    
          .p.name        = "apad",
    
          .p.description = NULL_IF_CONFIG_SMALL("Pad audio with silence."),
    
          .p.priv_class  = &apad_class,
    
          .p.flags       = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
    
          .init          = init,
    
          .activate      = activate,
    
          .priv_size     = sizeof(APadContext),
    
          FILTER_INPUTS(ff_audio_default_filterpad),
    
          FILTER_OUTPUTS(apad_outputs),
    
      };

隐翅虫吃什么	情形是什么意思	长脸适合什么发型女	腱鞘炎用什么药能治好	制冰机不制冰是什么原因
长情是什么意思	ais什么意思	韩束适合什么年龄段的人用	猪肉什么馅的饺子好吃	熵是什么
肺活量5000什么水平	活菩萨是什么意思	满族不吃什么肉	小动脉瘤是什么意思	蜂王浆是什么味道
尿白细胞高是什么原因	莲字五行属什么	邮电局是干什么的	甲状腺结节3类什么意思	带鱼为什么是扁的

食管反流吃什么药hcv8jop3ns2r.cn	痹病是什么意思hcv9jop2ns4r.cn	射精是什么感觉hcv8jop0ns4r.cn	的确良是什么面料jiuxinfghf.com	盛情款待是什么意思hcv8jop4ns8r.cn
聚字五行属什么hcv9jop3ns0r.cn	耳朵里面疼用什么药hcv8jop1ns0r.cn	背后长疙瘩是什么原因hcv9jop7ns9r.cn	烫伤涂什么药膏hcv8jop9ns5r.cn	西瓜霜是什么hcv7jop4ns7r.cn
小鸟进屋有什么预兆吗hcv8jop3ns8r.cn	氪金是什么意思hcv9jop6ns3r.cn	前列腺增大钙化是什么意思wzqsfys.com	世界上最难的数学题是什么hcv8jop6ns5r.cn	两眼中间的位置叫什么hcv8jop8ns5r.cn
今年阴历是什么年hcv8jop7ns6r.cn	无花果什么时候种植cl108k.com	煲仔饭用什么米最好hebeidezhi.com	cbd是什么意思啊hcv7jop9ns8r.cn	蛋白粉什么时间喝最好weuuu.com

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2012 Michael Niedermayer
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			/**
22			* @file
23			* audio pad filter.
24			*
25			* Based on af_aresample.c
26			*/
27
28			#include "libavutil/avstring.h"
29			#include "libavutil/channel_layout.h"
30			#include "libavutil/opt.h"
31			#include "libavutil/samplefmt.h"
32			#include "libavutil/avassert.h"
33			#include "avfilter.h"
34			#include "audio.h"
35			#include "filters.h"
36
37			typedef struct APadContext {
38			const AVClass *class;
39			int64_t next_pts;
40
41			int eof;
42			int packet_size;
43			int64_t pad_len, pad_len_left;
44			int64_t whole_len, whole_len_left;
45			int64_t pad_dur;
46			int64_t whole_dur;
47			} APadContext;
48
49			#define OFFSET(x) offsetof(APadContext, x)
50			#define A AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM
51
52			static const AVOption apad_options[] = {
53			{ "packet_size", "set silence packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, { .i64 = 4096 }, 0, INT_MAX, A },
54			{ "pad_len", "set number of samples of silence to add", OFFSET(pad_len), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, A },
55			{ "whole_len", "set minimum target number of samples in the audio stream", OFFSET(whole_len), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX, A },
56			{ "pad_dur", "set duration of silence to add", OFFSET(pad_dur), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, A },
57			{ "whole_dur", "set minimum target duration in the audio stream", OFFSET(whole_dur), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT64_MAX, A },
58			{ NULL }
59			};
60
61			AVFILTER_DEFINE_CLASS(apad);
62
63		2	static av_cold int init(AVFilterContext *ctx)
64			{
65		2	APadContext *s = ctx->priv;
66
67		2	s->next_pts = AV_NOPTS_VALUE;
68	1/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✗ Branch 3 not taken.	2	if (s->whole_len >= 0 && s->pad_len >= 0) {
69		✗	av_log(ctx, AV_LOG_ERROR, "Both whole and pad length are set, this is not possible\n");
70		✗	return AVERROR(EINVAL);
71			}
72
73		2	return 0;
74			}
75
76		65	static int filter_frame(AVFilterLink inlink, AVFrame frame)
77			{
78		65	AVFilterContext *ctx = inlink->dst;
79		65	APadContext *s = ctx->priv;
80
81	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 65 times.	65	if (s->whole_len >= 0) {
82		✗	s->whole_len_left = FFMAX(s->whole_len_left - frame->nb_samples, 0);
83		✗	av_log(ctx, AV_LOG_DEBUG,
84			"n_out:%d whole_len_left:%"PRId64"\n", frame->nb_samples, s->whole_len_left);
85			}
86
87		65	s->next_pts = frame->pts + av_rescale_q(frame->nb_samples, (AVRational){1, inlink->sample_rate}, inlink->time_base);
88		65	return ff_filter_frame(ctx->outputs[0], frame);
89			}
90
91		2	static int push_frame(AVFilterLink *outlink)
92			{
93		2	AVFilterContext *ctx = outlink->src;
94		2	APadContext *s = ctx->priv;
95			AVFrame *outsamplesref;
96			int n_out;
97
98	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times.	2	if (ctx->is_disabled)
99		✗	return 0;
100		2	n_out = s->packet_size;
101
102	1/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✗ Branch 3 not taken.	2	if (s->whole_len >= 0 && s->pad_len < 0) {
103		✗	s->pad_len = s->pad_len_left = s->whole_len_left;
104			}
105	1/4 ✗ Branch 0 not taken. ✓ Branch 1 taken 2 times. ✗ Branch 2 not taken. ✗ Branch 3 not taken.	2	if (s->pad_len >=0 \|\| s->whole_len >= 0) {
106		2	n_out = FFMIN(n_out, s->pad_len_left);
107		2	s->pad_len_left -= n_out;
108		2	av_log(ctx, AV_LOG_DEBUG,
109			"padding n_out:%d pad_len_left:%"PRId64"\n", n_out, s->pad_len_left);
110			}
111
112	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 1 times.	2	if (!n_out)
113		1	return AVERROR_EOF;
114
115		1	outsamplesref = ff_get_audio_buffer(outlink, n_out);
116	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (!outsamplesref)
117		✗	return AVERROR(ENOMEM);
118
119	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	av_assert0(outsamplesref->sample_rate == outlink->sample_rate);
120	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	av_assert0(outsamplesref->nb_samples == n_out);
121
122		1	av_samples_set_silence(outsamplesref->extended_data, 0,
123			n_out,
124			outsamplesref->ch_layout.nb_channels,
125		1	outsamplesref->format);
126
127		1	outsamplesref->pts = s->next_pts;
128	1/2 ✓ Branch 0 taken 1 times. ✗ Branch 1 not taken.	1	if (s->next_pts != AV_NOPTS_VALUE)
129		1	s->next_pts += av_rescale_q(n_out, (AVRational){1, outlink->sample_rate}, outlink->time_base);
130
131		1	return ff_filter_frame(outlink, outsamplesref);
132			}
133
134		132	static int activate(AVFilterContext *ctx)
135			{
136		132	AVFilterLink *inlink = ctx->inputs[0];
137		132	AVFilterLink *outlink = ctx->outputs[0];
138		132	APadContext *s = ctx->priv;
139			int64_t pts;
140			int status;
141
142	1/2 ✗ Branch 1 not taken. ✓ Branch 2 taken 132 times.	132	FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
143
144	4/4 ✓ Branch 0 taken 131 times. ✓ Branch 1 taken 1 times. ✓ Branch 3 taken 65 times. ✓ Branch 4 taken 66 times.	132	if (!s->eof && ff_inlink_queued_frames(inlink)) {
145		65	AVFrame *frame = NULL;
146			int ret;
147
148		65	ret = ff_inlink_consume_frame(inlink, &frame);
149	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 65 times.	65	if (ret < 0)
150		65	return ret;
151	1/2 ✓ Branch 0 taken 65 times. ✗ Branch 1 not taken.	65	if (ret > 0)
152		65	return filter_frame(inlink, frame);
153			}
154
155	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))
156		1	s->eof = status == AVERROR_EOF;
157
158	2/2 ✓ Branch 0 taken 2 times. ✓ Branch 1 taken 65 times.	67	if (s->eof) {
159		2	int ret = push_frame(outlink);
160
161	2/2 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 1 times.	2	if (ret == AVERROR_EOF) {
162		1	ff_outlink_set_status(outlink, AVERROR_EOF, s->next_pts);
163		1	return 0;
164			}
165		1	return ret;
166			}
167
168	1/2 ✓ Branch 1 taken 65 times. ✗ Branch 2 not taken.	65	FF_FILTER_FORWARD_WANTED(outlink, inlink);
169
170		✗	return FFERROR_NOT_READY;
171			}
172
173		1	static int config_output(AVFilterLink *outlink)
174			{
175		1	AVFilterContext *ctx = outlink->src;
176		1	APadContext *s = ctx->priv;
177
178	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (s->pad_dur >= 0)
179		✗	s->pad_len = av_rescale(s->pad_dur, outlink->sample_rate, AV_TIME_BASE);
180	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 1 times.	1	if (s->whole_dur >= 0)
181		✗	s->whole_len = av_rescale(s->whole_dur, outlink->sample_rate, AV_TIME_BASE);
182
183		1	s->pad_len_left = s->pad_len;
184		1	s->whole_len_left = s->whole_len;
185
186		1	return 0;
187			}
188
189			static const AVFilterPad apad_outputs[] = {
190			{
191			.name = "default",
192			.type = AVMEDIA_TYPE_AUDIO,
193			.config_props = config_output,
194			},
195			};
196
197			const FFFilter ff_af_apad = {
198			.p.name = "apad",
199			.p.description = NULL_IF_CONFIG_SMALL("Pad audio with silence."),
200			.p.priv_class = &apad_class,
201			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
202			.init = init,
203			.activate = activate,
204			.priv_size = sizeof(APadContext),
205			FILTER_INPUTS(ff_audio_default_filterpad),
206			FILTER_OUTPUTS(apad_outputs),
207			};
208

Function (Line)	Call count	Block coverage
activate (line 134)	called 132 times, returned 132 times	84.0%
config_output (line 173)	called 1 time, returned 1 time	67.0%
filter_frame (line 76)	called 65 times, returned 65 times	80.0%
init (line 63)	called 2 times, returned 2 times	50.0%
push_frame (line 91)	called 2 times, returned 2 times	62.0%