FFmpeg coverage

Directory:	../../../ffmpeg/
File:	src/libavfilter/f_interleave.c
Date:	2026-04-19 20:43:40

	Total	Coverage
Lines:	95	0.0%
Functions:	3	0.0%
Branches:	73	0.0%

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (c) 2013 Stefano Sabatini
    
       *
    
       * 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 and video interleaver
    
       */
    
      #include "config_components.h"
    
      #include "libavutil/avassert.h"
    
      #include "libavutil/avstring.h"
    
      #include "libavutil/opt.h"
    
      #include "avfilter.h"
    
      #include "filters.h"
    
      #include "audio.h"
    
      #include "video.h"
    
      typedef struct InterleaveContext {
    
          const AVClass *class;
    
          int nb_inputs;
    
          int duration_mode;
    
          int64_t pts;
    
      } InterleaveContext;
    
      #define DURATION_LONGEST  0
    
      #define DURATION_SHORTEST 1
    
      #define DURATION_FIRST    2
    
      #define OFFSET(x) offsetof(InterleaveContext, x)
    
      #define DEFINE_OPTIONS(filt_name, flags_)                           \
    
      static const AVOption filt_name##_options[] = {                     \
    
         { "nb_inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
    
         { "n",         "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
    
         { "duration", "how to determine the end-of-stream",              \
    
             OFFSET(duration_mode), AV_OPT_TYPE_INT, { .i64 = DURATION_LONGEST }, 0,  2, flags_, .unit = "duration" }, \
    
             { "longest",  "Duration of longest input",  0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST  }, 0, 0, flags_, .unit = "duration" }, \
    
             { "shortest", "Duration of shortest input", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, 0, 0, flags_, .unit = "duration" }, \
    
             { "first",    "Duration of first input",    0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST    }, 0, 0, flags_, .unit = "duration" }, \
    
         { NULL }                                                         \
    
      }
    
      ✗
      static int activate(AVFilterContext *ctx)
    
      {
    
      ✗
          AVFilterLink *outlink = ctx->outputs[0];
    
      ✗
          InterleaveContext *s = ctx->priv;
    
      ✗
          int64_t q_pts, pts = INT64_MAX;
    
      ✗
          int i, nb_eofs = 0, input_idx = -1;
    
      ✗
          int first_eof = 0;
    
          int64_t rpts;
    
          int status;
    
      ✗
          int nb_inputs_with_frames = 0;
    
      ✗
          FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
    
      ✗
          for (i = 0; i < ctx->nb_inputs; i++) {
    
      ✗
              int is_eof = !!ff_inlink_acknowledge_status(ctx->inputs[i], &status, &rpts);
    
      ✗
              nb_eofs += is_eof;
    
      ✗
              if (i == 0)
    
      ✗
                  first_eof = is_eof;
    
          }
    
      ✗
          if ((nb_eofs > 0 && s->duration_mode == DURATION_SHORTEST) ||
    
      ✗
              (nb_eofs == ctx->nb_inputs && s->duration_mode == DURATION_LONGEST) ||
    
      ✗
              (first_eof && s->duration_mode == DURATION_FIRST)) {
    
      ✗
              ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);
    
      ✗
              return 0;
    
          }
    
      ✗
          for (i = 0; i < ctx->nb_inputs; i++) {
    
      ✗
              if (!ff_inlink_queued_frames(ctx->inputs[i]))
    
      ✗
                  continue;
    
      ✗
              nb_inputs_with_frames++;
    
          }
    
      ✗
          if (nb_inputs_with_frames >= ctx->nb_inputs - nb_eofs) {
    
      ✗
              for (i = 0; i < ctx->nb_inputs; i++) {
    
                  AVFrame *frame;
    
      ✗
                  if (ff_inlink_queued_frames(ctx->inputs[i]) == 0)
    
      ✗
                      continue;
    
      ✗
                  frame = ff_inlink_peek_frame(ctx->inputs[i], 0);
    
      ✗
                  if (frame->pts == AV_NOPTS_VALUE) {
    
                      int ret;
    
      ✗
                      av_log(ctx, AV_LOG_WARNING,
    
                             "NOPTS value for input frame cannot be accepted, frame discarded\n");
    
      ✗
                      ret = ff_inlink_consume_frame(ctx->inputs[i], &frame);
    
      ✗
                      if (ret < 0)
    
      ✗
                          return ret;
    
      ✗
                      av_frame_free(&frame);
    
      ✗
                      return AVERROR_INVALIDDATA;
    
                  }
    
      ✗
                  q_pts = av_rescale_q(frame->pts, ctx->inputs[i]->time_base, AV_TIME_BASE_Q);
    
      ✗
                  if (q_pts < pts) {
    
      ✗
                      pts = q_pts;
    
      ✗
                      input_idx = i;
    
                  }
    
              }
    
      ✗
              if (input_idx >= 0) {
    
                  AVFrame *frame;
    
                  int ret;
    
      ✗
                  ret = ff_inlink_consume_frame(ctx->inputs[input_idx], &frame);
    
      ✗
                  if (ret < 0)
    
      ✗
                      return ret;
    
      ✗
                  frame->pts = s->pts = pts;
    
      ✗
                  return ff_filter_frame(outlink, frame);
    
              }
    
          }
    
      ✗
          for (i = 0; i < ctx->nb_inputs; i++) {
    
      ✗
              if (ff_inlink_queued_frames(ctx->inputs[i]))
    
      ✗
                  continue;
    
      ✗
              if (ff_outlink_frame_wanted(outlink) &&
    
      ✗
                  !ff_outlink_get_status(ctx->inputs[i])) {
    
      ✗
                  ff_inlink_request_frame(ctx->inputs[i]);
    
      ✗
                  return 0;
    
              }
    
          }
    
      ✗
          if (i == ctx->nb_inputs - nb_eofs && ff_outlink_frame_wanted(outlink)) {
    
      ✗
              ff_filter_set_ready(ctx, 100);
    
      ✗
              return 0;
    
          }
    
      ✗
          return FFERROR_NOT_READY;
    
      }
    
      ✗
      static av_cold int init(AVFilterContext *ctx)
    
      {
    
      ✗
          InterleaveContext *s = ctx->priv;
    
      ✗
          const AVFilterPad *outpad = &ctx->filter->outputs[0];
    
          int i, ret;
    
      ✗
          for (i = 0; i < s->nb_inputs; i++) {
    
      ✗
              AVFilterPad inpad = { 0 };
    
      ✗
              inpad.name = av_asprintf("input%d", i);
    
      ✗
              if (!inpad.name)
    
      ✗
                  return AVERROR(ENOMEM);
    
      ✗
              inpad.type         = outpad->type;
    
      ✗
              switch (outpad->type) {
    
      ✗
              case AVMEDIA_TYPE_VIDEO:
    
      ✗
                  inpad.get_buffer.video = ff_null_get_video_buffer; break;
    
      ✗
              case AVMEDIA_TYPE_AUDIO:
    
      ✗
                  inpad.get_buffer.audio = ff_null_get_audio_buffer; break;
    
      ✗
              default:
    
      ✗
                  av_assert0(0);
    
              }
    
      ✗
              if ((ret = ff_append_inpad_free_name(ctx, &inpad)) < 0)
    
      ✗
                  return ret;
    
          }
    
      ✗
          return 0;
    
      }
    
      ✗
      static int config_output(AVFilterLink *outlink)
    
      {
    
      ✗
          FilterLink *l = ff_filter_link(outlink);
    
      ✗
          AVFilterContext *ctx = outlink->src;
    
      ✗
          AVFilterLink *inlink0 = ctx->inputs[0];
    
          int i;
    
      ✗
          if (outlink->type == AVMEDIA_TYPE_VIDEO) {
    
      ✗
              outlink->time_base           = AV_TIME_BASE_Q;
    
      ✗
              outlink->w                   = inlink0->w;
    
      ✗
              outlink->h                   = inlink0->h;
    
      ✗
              outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
    
      ✗
              outlink->format              = inlink0->format;
    
      ✗
              l->frame_rate = (AVRational) {1, 0};
    
      ✗
              for (i = 1; i < ctx->nb_inputs; i++) {
    
      ✗
                  AVFilterLink *inlink = ctx->inputs[i];
    
      ✗
                  if (outlink->w                       != inlink->w                       ||
    
      ✗
                      outlink->h                       != inlink->h                       ||
    
      ✗
                      outlink->sample_aspect_ratio.num != inlink->sample_aspect_ratio.num ||
    
      ✗
                      outlink->sample_aspect_ratio.den != inlink->sample_aspect_ratio.den) {
    
      ✗
                      av_log(ctx, AV_LOG_ERROR, "Parameters for input link %s "
    
                             "(size %dx%d, SAR %d:%d) do not match the corresponding "
    
                             "output link parameters (%dx%d, SAR %d:%d)\n",
    
      ✗
                             ctx->input_pads[i].name, inlink->w, inlink->h,
    
                             inlink->sample_aspect_ratio.num,
    
                             inlink->sample_aspect_ratio.den,
    
                             outlink->w, outlink->h,
    
                             outlink->sample_aspect_ratio.num,
    
                             outlink->sample_aspect_ratio.den);
    
      ✗
                      return AVERROR(EINVAL);
    
                  }
    
              }
    
          }
    
      ✗
          return 0;
    
      }
    
      #if CONFIG_INTERLEAVE_FILTER
    
      DEFINE_OPTIONS(interleave, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
    
      AVFILTER_DEFINE_CLASS(interleave);
    
      static const AVFilterPad interleave_outputs[] = {
    
          {
    
              .name          = "default",
    
              .type          = AVMEDIA_TYPE_VIDEO,
    
              .config_props  = config_output,
    
          },
    
      };
    
      const FFFilter ff_vf_interleave = {
    
          .p.name        = "interleave",
    
          .p.description = NULL_IF_CONFIG_SMALL("Temporally interleave video inputs."),
    
          .p.priv_class  = &interleave_class,
    
          .p.flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
    
          .priv_size   = sizeof(InterleaveContext),
    
          .init        = init,
    
          .activate    = activate,
    
          FILTER_OUTPUTS(interleave_outputs),
    
      };
    
      #endif
    
      #if CONFIG_AINTERLEAVE_FILTER
    
      DEFINE_OPTIONS(ainterleave, AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_FILTERING_PARAM);
    
      AVFILTER_DEFINE_CLASS(ainterleave);
    
      static const AVFilterPad ainterleave_outputs[] = {
    
          {
    
              .name          = "default",
    
              .type          = AVMEDIA_TYPE_AUDIO,
    
              .config_props  = config_output,
    
          },
    
      };
    
      const FFFilter ff_af_ainterleave = {
    
          .p.name        = "ainterleave",
    
          .p.description = NULL_IF_CONFIG_SMALL("Temporally interleave audio inputs."),
    
          .p.priv_class  = &ainterleave_class,
    
          .p.flags       = AVFILTER_FLAG_DYNAMIC_INPUTS,
    
          .priv_size   = sizeof(InterleaveContext),
    
          .init        = init,
    
          .activate    = activate,
    
          FILTER_OUTPUTS(ainterleave_outputs),
    
      };
    
      #endif

Line	Exec	Source
1		/*
2		* Copyright (c) 2013 Stefano Sabatini
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 and video interleaver
24		*/
25
26		#include "config_components.h"
27
28		#include "libavutil/avassert.h"
29		#include "libavutil/avstring.h"
30		#include "libavutil/opt.h"
31
32		#include "avfilter.h"
33		#include "filters.h"
34		#include "audio.h"
35		#include "video.h"
36
37		typedef struct InterleaveContext {
38		const AVClass *class;
39		int nb_inputs;
40		int duration_mode;
41		int64_t pts;
42		} InterleaveContext;
43
44		#define DURATION_LONGEST 0
45		#define DURATION_SHORTEST 1
46		#define DURATION_FIRST 2
47
48		#define OFFSET(x) offsetof(InterleaveContext, x)
49
50		#define DEFINE_OPTIONS(filt_name, flags_) \
51		static const AVOption filt_name##_options[] = { \
52		{ "nb_inputs", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
53		{ "n", "set number of inputs", OFFSET(nb_inputs), AV_OPT_TYPE_INT, {.i64 = 2}, 1, INT_MAX, .flags = flags_ }, \
54		{ "duration", "how to determine the end-of-stream", \
55		OFFSET(duration_mode), AV_OPT_TYPE_INT, { .i64 = DURATION_LONGEST }, 0, 2, flags_, .unit = "duration" }, \
56		{ "longest", "Duration of longest input", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST }, 0, 0, flags_, .unit = "duration" }, \
57		{ "shortest", "Duration of shortest input", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, 0, 0, flags_, .unit = "duration" }, \
58		{ "first", "Duration of first input", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST }, 0, 0, flags_, .unit = "duration" }, \
59		{ NULL } \
60		}
61
62	✗	static int activate(AVFilterContext *ctx)
63		{
64	✗	AVFilterLink *outlink = ctx->outputs[0];
65	✗	InterleaveContext *s = ctx->priv;
66	✗	int64_t q_pts, pts = INT64_MAX;
67	✗	int i, nb_eofs = 0, input_idx = -1;
68	✗	int first_eof = 0;
69		int64_t rpts;
70		int status;
71	✗	int nb_inputs_with_frames = 0;
72
73	✗	FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
74
75	✗	for (i = 0; i < ctx->nb_inputs; i++) {
76	✗	int is_eof = !!ff_inlink_acknowledge_status(ctx->inputs[i], &status, &rpts);
77
78	✗	nb_eofs += is_eof;
79	✗	if (i == 0)
80	✗	first_eof = is_eof;
81		}
82
83	✗	if ((nb_eofs > 0 && s->duration_mode == DURATION_SHORTEST) \|\|
84	✗	(nb_eofs == ctx->nb_inputs && s->duration_mode == DURATION_LONGEST) \|\|
85	✗	(first_eof && s->duration_mode == DURATION_FIRST)) {
86	✗	ff_outlink_set_status(outlink, AVERROR_EOF, s->pts);
87	✗	return 0;
88		}
89
90	✗	for (i = 0; i < ctx->nb_inputs; i++) {
91	✗	if (!ff_inlink_queued_frames(ctx->inputs[i]))
92	✗	continue;
93	✗	nb_inputs_with_frames++;
94		}
95
96	✗	if (nb_inputs_with_frames >= ctx->nb_inputs - nb_eofs) {
97	✗	for (i = 0; i < ctx->nb_inputs; i++) {
98		AVFrame *frame;
99
100	✗	if (ff_inlink_queued_frames(ctx->inputs[i]) == 0)
101	✗	continue;
102
103	✗	frame = ff_inlink_peek_frame(ctx->inputs[i], 0);
104	✗	if (frame->pts == AV_NOPTS_VALUE) {
105		int ret;
106
107	✗	av_log(ctx, AV_LOG_WARNING,
108		"NOPTS value for input frame cannot be accepted, frame discarded\n");
109	✗	ret = ff_inlink_consume_frame(ctx->inputs[i], &frame);
110	✗	if (ret < 0)
111	✗	return ret;
112	✗	av_frame_free(&frame);
113	✗	return AVERROR_INVALIDDATA;
114		}
115
116	✗	q_pts = av_rescale_q(frame->pts, ctx->inputs[i]->time_base, AV_TIME_BASE_Q);
117	✗	if (q_pts < pts) {
118	✗	pts = q_pts;
119	✗	input_idx = i;
120		}
121		}
122
123	✗	if (input_idx >= 0) {
124		AVFrame *frame;
125		int ret;
126
127	✗	ret = ff_inlink_consume_frame(ctx->inputs[input_idx], &frame);
128	✗	if (ret < 0)
129	✗	return ret;
130
131	✗	frame->pts = s->pts = pts;
132	✗	return ff_filter_frame(outlink, frame);
133		}
134		}
135
136	✗	for (i = 0; i < ctx->nb_inputs; i++) {
137	✗	if (ff_inlink_queued_frames(ctx->inputs[i]))
138	✗	continue;
139	✗	if (ff_outlink_frame_wanted(outlink) &&
140	✗	!ff_outlink_get_status(ctx->inputs[i])) {
141	✗	ff_inlink_request_frame(ctx->inputs[i]);
142	✗	return 0;
143		}
144		}
145
146	✗	if (i == ctx->nb_inputs - nb_eofs && ff_outlink_frame_wanted(outlink)) {
147	✗	ff_filter_set_ready(ctx, 100);
148	✗	return 0;
149		}
150
151	✗	return FFERROR_NOT_READY;
152		}
153
154	✗	static av_cold int init(AVFilterContext *ctx)
155		{
156	✗	InterleaveContext *s = ctx->priv;
157	✗	const AVFilterPad *outpad = &ctx->filter->outputs[0];
158		int i, ret;
159
160	✗	for (i = 0; i < s->nb_inputs; i++) {
161	✗	AVFilterPad inpad = { 0 };
162
163	✗	inpad.name = av_asprintf("input%d", i);
164	✗	if (!inpad.name)
165	✗	return AVERROR(ENOMEM);
166	✗	inpad.type = outpad->type;
167
168	✗	switch (outpad->type) {
169	✗	case AVMEDIA_TYPE_VIDEO:
170	✗	inpad.get_buffer.video = ff_null_get_video_buffer; break;
171	✗	case AVMEDIA_TYPE_AUDIO:
172	✗	inpad.get_buffer.audio = ff_null_get_audio_buffer; break;
173	✗	default:
174	✗	av_assert0(0);
175		}
176	✗	if ((ret = ff_append_inpad_free_name(ctx, &inpad)) < 0)
177	✗	return ret;
178		}
179
180	✗	return 0;
181		}
182
183	✗	static int config_output(AVFilterLink *outlink)
184		{
185	✗	FilterLink *l = ff_filter_link(outlink);
186	✗	AVFilterContext *ctx = outlink->src;
187	✗	AVFilterLink *inlink0 = ctx->inputs[0];
188		int i;
189
190	✗	if (outlink->type == AVMEDIA_TYPE_VIDEO) {
191	✗	outlink->time_base = AV_TIME_BASE_Q;
192	✗	outlink->w = inlink0->w;
193	✗	outlink->h = inlink0->h;
194	✗	outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
195	✗	outlink->format = inlink0->format;
196	✗	l->frame_rate = (AVRational) {1, 0};
197	✗	for (i = 1; i < ctx->nb_inputs; i++) {
198	✗	AVFilterLink *inlink = ctx->inputs[i];
199
200	✗	if (outlink->w != inlink->w \|\|
201	✗	outlink->h != inlink->h \|\|
202	✗	outlink->sample_aspect_ratio.num != inlink->sample_aspect_ratio.num \|\|
203	✗	outlink->sample_aspect_ratio.den != inlink->sample_aspect_ratio.den) {
204	✗	av_log(ctx, AV_LOG_ERROR, "Parameters for input link %s "
205		"(size %dx%d, SAR %d:%d) do not match the corresponding "
206		"output link parameters (%dx%d, SAR %d:%d)\n",
207	✗	ctx->input_pads[i].name, inlink->w, inlink->h,
208		inlink->sample_aspect_ratio.num,
209		inlink->sample_aspect_ratio.den,
210		outlink->w, outlink->h,
211		outlink->sample_aspect_ratio.num,
212		outlink->sample_aspect_ratio.den);
213	✗	return AVERROR(EINVAL);
214		}
215		}
216		}
217	✗	return 0;
218		}
219
220		#if CONFIG_INTERLEAVE_FILTER
221
222		DEFINE_OPTIONS(interleave, AV_OPT_FLAG_VIDEO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM);
223		AVFILTER_DEFINE_CLASS(interleave);
224
225		static const AVFilterPad interleave_outputs[] = {
226		{
227		.name = "default",
228		.type = AVMEDIA_TYPE_VIDEO,
229		.config_props = config_output,
230		},
231		};
232
233		const FFFilter ff_vf_interleave = {
234		.p.name = "interleave",
235		.p.description = NULL_IF_CONFIG_SMALL("Temporally interleave video inputs."),
236		.p.priv_class = &interleave_class,
237		.p.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
238		.priv_size = sizeof(InterleaveContext),
239		.init = init,
240		.activate = activate,
241		FILTER_OUTPUTS(interleave_outputs),
242		};
243
244		#endif
245
246		#if CONFIG_AINTERLEAVE_FILTER
247
248		DEFINE_OPTIONS(ainterleave, AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_FILTERING_PARAM);
249		AVFILTER_DEFINE_CLASS(ainterleave);
250
251		static const AVFilterPad ainterleave_outputs[] = {
252		{
253		.name = "default",
254		.type = AVMEDIA_TYPE_AUDIO,
255		.config_props = config_output,
256		},
257		};
258
259		const FFFilter ff_af_ainterleave = {
260		.p.name = "ainterleave",
261		.p.description = NULL_IF_CONFIG_SMALL("Temporally interleave audio inputs."),
262		.p.priv_class = &ainterleave_class,
263		.p.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
264		.priv_size = sizeof(InterleaveContext),
265		.init = init,
266		.activate = activate,
267		FILTER_OUTPUTS(ainterleave_outputs),
268		};
269
270		#endif
271

Function (Line)	Call count	Block coverage
activate (line 62)	not called	0.0%
config_output (line 183)	not called	0.0%
init (line 154)	not called	0.0%