History

avfilter: add xfade filter

Paul B Mahol committed 7 years ago

Commit 863accb1 parent 60876926 files · +1019 −1Browse files

Unified · Split

6 files
  1. Changelog +1 −0
  2. doc/filters.texi +80 −0
  3. libavfilter/Makefile +1 −0
  4. libavfilter/allfilters.c +1 −0
  5. libavfilter/version.h +1 −1
  6. libavfilter/vf_xfade.c +935 −0
Changelog+1−0
@@ -32,6 +32,7 @@ version <next>: · 31 unmodified lines
32- freezeframes filter32- freezeframes filter
33- Argonaut Games ADPCM decoder33- Argonaut Games ADPCM decoder
34- Argonaut Games ASF demuxer34- Argonaut Games ASF demuxer
35- xfade video filter
35 36
36 37
37version 4.2:38version 4.2:
doc/filters.texi+80−0
@@ -20033,6 +20033,86 @@ If number of inputs is even number, than result will be mean value between two m · 20032 unmodified lines
20033Set which planes to filter. Default value is @code{15}, by which all planes are processed.20033Set which planes to filter. Default value is @code{15}, by which all planes are processed.
20034@end table20034@end table
20035 20035
20036@section xfade
20037
20038Apply cross fade from one input video stream to another input video stream.
20039The cross fade is applied for specified duration.
20040
20041The filter accepts the following options:
20042
20043@table @option
20044@item transition
20045Set one of available transition effects:
20046
20047@table @samp
20048@item custom
20049@item fade
20050@item wipeleft
20051@item wiperight
20052@item wipeup
20053@item wipedown
20054@item slideleft
20055@item slideright
20056@item slideup
20057@item slidedown
20058@item circlecrop
20059@item rectcrop
20060@item distance
20061@item fadeblack
20062@item fadewhite
20063@end table
20064Default transition effect is fade.
20065
20066@item duration
20067Set cross fade duration in seconds.
20068Default duration is 1 second.
20069
20070@item offset
20071Set cross fade start relative to first input stream.
20072Default offset it 0.
20073
20074@item expr
20075Set expression for custom transition effect.
20076
20077The expressions can use the following variables and functions:
20078
20079@table @option
20080@item X
20081@item Y
20082The coordinates of the current sample.
20083
20084@item W
20085@item H
20086The width and height of the image.
20087
20088@item P
20089Progress of transition effect.
20090
20091@item PLANE
20092Currently processed plane.
20093
20094@item A
20095Return value of first input at current location and plane.
20096
20097@item B
20098Return value of second input at current location and plane.
20099
20100@item a0(x, y)
20101@item a1(x, y)
20102@item a2(x, y)
20103@item a3(x, y)
20104Return the value of the pixel at location (@var{x},@var{y}) of the
20105first/second/third/fourth component of first input.
20106
20107@item b0(x, y)
20108@item b1(x, y)
20109@item b2(x, y)
20110@item b3(x, y)
20111Return the value of the pixel at location (@var{x},@var{y}) of the
20112first/second/third/fourth component of second input.
20113@end table
20114@end table
20115
20036@section xstack20116@section xstack
20037Stack video inputs into custom layout.20117Stack video inputs into custom layout.
20038 20118
libavfilter/Makefile+1−0
@@ -441,6 +441,7 @@ OBJS-$(CONFIG_W3FDIF_FILTER) += vf_w3fdif.o · 440 unmodified lines
441OBJS-$(CONFIG_WAVEFORM_FILTER) += vf_waveform.o441OBJS-$(CONFIG_WAVEFORM_FILTER) += vf_waveform.o
442OBJS-$(CONFIG_WEAVE_FILTER) += vf_weave.o442OBJS-$(CONFIG_WEAVE_FILTER) += vf_weave.o
443OBJS-$(CONFIG_XBR_FILTER) += vf_xbr.o443OBJS-$(CONFIG_XBR_FILTER) += vf_xbr.o
444OBJS-$(CONFIG_XFADE_FILTER) += vf_xfade.o
444OBJS-$(CONFIG_XMEDIAN_FILTER) += vf_xmedian.o framesync.o445OBJS-$(CONFIG_XMEDIAN_FILTER) += vf_xmedian.o framesync.o
445OBJS-$(CONFIG_XSTACK_FILTER) += vf_stack.o framesync.o446OBJS-$(CONFIG_XSTACK_FILTER) += vf_stack.o framesync.o
446OBJS-$(CONFIG_YADIF_FILTER) += vf_yadif.o yadif_common.o447OBJS-$(CONFIG_YADIF_FILTER) += vf_yadif.o yadif_common.o
libavfilter/allfilters.c+1−0
@@ -420,6 +420,7 @@ extern AVFilter ff_vf_w3fdif; · 419 unmodified lines
420extern AVFilter ff_vf_waveform;420extern AVFilter ff_vf_waveform;
421extern AVFilter ff_vf_weave;421extern AVFilter ff_vf_weave;
422extern AVFilter ff_vf_xbr;422extern AVFilter ff_vf_xbr;
423extern AVFilter ff_vf_xfade;
423extern AVFilter ff_vf_xmedian;424extern AVFilter ff_vf_xmedian;
424extern AVFilter ff_vf_xstack;425extern AVFilter ff_vf_xstack;
425extern AVFilter ff_vf_yadif;426extern AVFilter ff_vf_yadif;
libavfilter/version.h+1−1
@@ -30,7 +30,7 @@ · 29 unmodified lines
30#include "libavutil/version.h"30#include "libavutil/version.h"
31 31
32#define LIBAVFILTER_VERSION_MAJOR 732#define LIBAVFILTER_VERSION_MAJOR 7
33#define LIBAVFILTER_VERSION_MINOR 7133#define LIBAVFILTER_VERSION_MINOR 72
34#define LIBAVFILTER_VERSION_MICRO 10034#define LIBAVFILTER_VERSION_MICRO 100
35 35
36 36
libavfilter/vf_xfade.c+935−0
@@ -0,0 +1,935 @@
1/*
2 * Copyright (c) 2020 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/imgutils.h"
22#include "libavutil/eval.h"
23#include "libavutil/opt.h"
24#include "libavutil/pixfmt.h"
25#include "avfilter.h"
26#include "formats.h"
27#include "framesync.h"
28#include "internal.h"
29#include "filters.h"
30#include "video.h"
31
32enum XFadeTransitions {
33 CUSTOM = -1,
34 FADE,
35 WIPELEFT,
36 WIPERIGHT,
37 WIPEUP,
38 WIPEDOWN,
39 SLIDELEFT,
40 SLIDERIGHT,
41 SLIDEUP,
42 SLIDEDOWN,
43 CIRCLECROP,
44 RECTCROP,
45 DISTANCE,
46 FADEBLACK,
47 FADEWHITE,
48 NB_TRANSITIONS,
49};
50
51typedef struct XFadeContext {
52 const AVClass *class;
53
54 int transition;
55 int64_t duration;
56 int64_t offset;
57 char *custom_str;
58
59 int nb_planes;
60 int depth;
61
62 int64_t duration_pts;
63 int64_t offset_pts;
64 int64_t first_pts;
65 int64_t last_pts;
66 int64_t pts;
67 int xfade_is_over;
68 int need_second;
69 int eof[2];
70 AVFrame *xf[2];
71 int max_value;
72 uint16_t black[4];
73 uint16_t white[4];
74
75 void (*transitionf)(AVFilterContext *ctx, const AVFrame *a, const AVFrame *b, AVFrame *out, float progress,
76 int slice_start, int slice_end, int jobnr);
77
78 AVExpr *e;
79} XFadeContext;
80
81static const char *const var_names[] = { "X", "Y", "W", "H", "A", "B", "PLANE", "P", NULL };
82enum { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_A, VAR_B, VAR_PLANE, VAR_PROGRESS, VAR_VARS_NB };
83
84typedef struct ThreadData {
85 const AVFrame *xf[2];
86 AVFrame *out;
87 float progress;
88} ThreadData;
89
90static int query_formats(AVFilterContext *ctx)
91{
92 static const enum AVPixelFormat pix_fmts[] = {
93 AV_PIX_FMT_YUVA444P,
94 AV_PIX_FMT_YUVJ444P,
95 AV_PIX_FMT_YUV444P,
96 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
97 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_GBRP9,
98 AV_PIX_FMT_YUV444P10,
99 AV_PIX_FMT_YUVA444P10,
100 AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GRAY10,
101 AV_PIX_FMT_YUV444P12,
102 AV_PIX_FMT_YUVA444P12,
103 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GRAY12,
104 AV_PIX_FMT_YUV444P14, AV_PIX_FMT_GBRP14,
105 AV_PIX_FMT_YUV444P16,
106 AV_PIX_FMT_YUVA444P16,
107 AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,
108 AV_PIX_FMT_NONE
109 };
110
111 AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
112 if (!fmts_list)
113 return AVERROR(ENOMEM);
114 return ff_set_common_formats(ctx, fmts_list);
115}
116
117static av_cold void uninit(AVFilterContext *ctx)
118{
119 XFadeContext *s = ctx->priv;
120
121 av_expr_free(s->e);
122}
123
124#define OFFSET(x) offsetof(XFadeContext, x)
125#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
126
127static const AVOption xfade_options[] = {
128 { "transition", "set cross fade transition", OFFSET(transition), AV_OPT_TYPE_INT, {.i64=FADE}, -1, NB_TRANSITIONS-1, FLAGS, "transition" },
129 { "custom", "custom transition", 0, AV_OPT_TYPE_CONST, {.i64=CUSTOM}, 0, 0, FLAGS, "transition" },
130 { "fade", "fade transition", 0, AV_OPT_TYPE_CONST, {.i64=FADE}, 0, 0, FLAGS, "transition" },
131 { "wipeleft", "wipe left transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPELEFT}, 0, 0, FLAGS, "transition" },
132 { "wiperight", "wipe right transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPERIGHT}, 0, 0, FLAGS, "transition" },
133 { "wipeup", "wipe up transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEUP}, 0, 0, FLAGS, "transition" },
134 { "wipedown", "wipe down transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEDOWN}, 0, 0, FLAGS, "transition" },
135 { "slideleft", "slide left transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDELEFT}, 0, 0, FLAGS, "transition" },
136 { "slideright", "slide right transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDERIGHT}, 0, 0, FLAGS, "transition" },
137 { "slideup", "slide up transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDEUP}, 0, 0, FLAGS, "transition" },
138 { "slidedown", "slide down transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDEDOWN}, 0, 0, FLAGS, "transition" },
139 { "circlecrop", "circle crop transition", 0, AV_OPT_TYPE_CONST, {.i64=CIRCLECROP}, 0, 0, FLAGS, "transition" },
140 { "rectcrop", "rect crop transition", 0, AV_OPT_TYPE_CONST, {.i64=RECTCROP}, 0, 0, FLAGS, "transition" },
141 { "distance", "distance transition", 0, AV_OPT_TYPE_CONST, {.i64=DISTANCE}, 0, 0, FLAGS, "transition" },
142 { "fadeblack", "fadeblack transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEBLACK}, 0, 0, FLAGS, "transition" },
143 { "fadewhite", "fadewhite transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEWHITE}, 0, 0, FLAGS, "transition" },
144 { "duration", "set cross fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=1000000}, 0, 60000000, FLAGS },
145 { "offset", "set cross fade start relative to first input stream", OFFSET(offset), AV_OPT_TYPE_DURATION, {.i64=0}, INT64_MIN, INT64_MAX, FLAGS },
146 { "expr", "set expression for custom transition", OFFSET(custom_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
147 { NULL }
148};
149
150AVFILTER_DEFINE_CLASS(xfade);
151
152#define CUSTOM_TRANSITION(name, type, div) \
153static void custom##name##_transition(AVFilterContext *ctx, \
154 const AVFrame *a, const AVFrame *b, AVFrame *out, \
155 float progress, \
156 int slice_start, int slice_end, int jobnr) \
157{ \
158 XFadeContext *s = ctx->priv; \
159 const int height = slice_end - slice_start; \
160 \
161 double values[VAR_VARS_NB]; \
162 values[VAR_W] = out->width; \
163 values[VAR_H] = out->height; \
164 values[VAR_PROGRESS] = progress; \
165 \
166 for (int p = 0; p < s->nb_planes; p++) { \
167 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
168 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
169 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
170 \
171 values[VAR_PLANE] = p; \
172 \
173 for (int y = 0; y < height; y++) { \
174 values[VAR_Y] = slice_start + y; \
175 for (int x = 0; x < out->width; x++) { \
176 values[VAR_X] = x; \
177 values[VAR_A] = xf0[x]; \
178 values[VAR_B] = xf1[x]; \
179 dst[x] = av_expr_eval(s->e, values, s); \
180 } \
181 \
182 dst += out->linesize[p] / div; \
183 xf0 += a->linesize[p] / div; \
184 xf1 += b->linesize[p] / div; \
185 } \
186 } \
187}
188
189CUSTOM_TRANSITION(8, uint8_t, 1)
190CUSTOM_TRANSITION(16, uint16_t, 2)
191
192static inline float mix(float a, float b, float mix)
193{
194 return a * mix + b * (1.f - mix);
195}
196
197static inline float smoothstep(float edge0, float edge1, float x)
198{
199 float t;
200
201 t = av_clipf((x - edge0) / (edge1 - edge0), 0.f, 1.f);
202
203 return t * t * (3.f - 2.f * t);
204}
205
206#define FADE_TRANSITION(name, type, div) \
207static void fade##name##_transition(AVFilterContext *ctx, \
208 const AVFrame *a, const AVFrame *b, AVFrame *out, \
209 float progress, \
210 int slice_start, int slice_end, int jobnr) \
211{ \
212 XFadeContext *s = ctx->priv; \
213 const int height = slice_end - slice_start; \
214 \
215 for (int p = 0; p < s->nb_planes; p++) { \
216 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
217 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
218 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
219 \
220 for (int y = 0; y < height; y++) { \
221 for (int x = 0; x < out->width; x++) { \
222 dst[x] = mix(xf0[x], xf1[x], progress); \
223 } \
224 \
225 dst += out->linesize[p] / div; \
226 xf0 += a->linesize[p] / div; \
227 xf1 += b->linesize[p] / div; \
228 } \
229 } \
230}
231
232FADE_TRANSITION(8, uint8_t, 1)
233FADE_TRANSITION(16, uint16_t, 2)
234
235#define WIPELEFT_TRANSITION(name, type, div) \
236static void wipeleft##name##_transition(AVFilterContext *ctx, \
237 const AVFrame *a, const AVFrame *b, AVFrame *out, \
238 float progress, \
239 int slice_start, int slice_end, int jobnr) \
240{ \
241 XFadeContext *s = ctx->priv; \
242 const int height = slice_end - slice_start; \
243 const int z = out->width * progress; \
244 \
245 for (int p = 0; p < s->nb_planes; p++) { \
246 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
247 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
248 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
249 \
250 for (int y = 0; y < height; y++) { \
251 for (int x = 0; x < out->width; x++) { \
252 dst[x] = x > z ? xf1[x] : xf0[x]; \
253 } \
254 \
255 dst += out->linesize[p] / div; \
256 xf0 += a->linesize[p] / div; \
257 xf1 += b->linesize[p] / div; \
258 } \
259 } \
260}
261
262WIPELEFT_TRANSITION(8, uint8_t, 1)
263WIPELEFT_TRANSITION(16, uint16_t, 2)
264
265#define WIPERIGHT_TRANSITION(name, type, div) \
266static void wiperight##name##_transition(AVFilterContext *ctx, \
267 const AVFrame *a, const AVFrame *b, AVFrame *out, \
268 float progress, \
269 int slice_start, int slice_end, int jobnr) \
270{ \
271 XFadeContext *s = ctx->priv; \
272 const int height = slice_end - slice_start; \
273 const int z = out->width * (1.f - progress); \
274 \
275 for (int p = 0; p < s->nb_planes; p++) { \
276 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
277 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
278 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
279 \
280 for (int y = 0; y < height; y++) { \
281 for (int x = 0; x < out->width; x++) { \
282 dst[x] = x > z ? xf0[x] : xf1[x]; \
283 } \
284 \
285 dst += out->linesize[p] / div; \
286 xf0 += a->linesize[p] / div; \
287 xf1 += b->linesize[p] / div; \
288 } \
289 } \
290}
291
292WIPERIGHT_TRANSITION(8, uint8_t, 1)
293WIPERIGHT_TRANSITION(16, uint16_t, 2)
294
295#define WIPEUP_TRANSITION(name, type, div) \
296static void wipeup##name##_transition(AVFilterContext *ctx, \
297 const AVFrame *a, const AVFrame *b, AVFrame *out, \
298 float progress, \
299 int slice_start, int slice_end, int jobnr) \
300{ \
301 XFadeContext *s = ctx->priv; \
302 const int height = slice_end - slice_start; \
303 const int z = out->height * progress; \
304 \
305 for (int p = 0; p < s->nb_planes; p++) { \
306 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
307 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
308 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
309 \
310 for (int y = 0; y < height; y++) { \
311 for (int x = 0; x < out->width; x++) { \
312 dst[x] = slice_start + y > z ? xf1[x] : xf0[x]; \
313 } \
314 \
315 dst += out->linesize[p] / div; \
316 xf0 += a->linesize[p] / div; \
317 xf1 += b->linesize[p] / div; \
318 } \
319 } \
320}
321
322WIPEUP_TRANSITION(8, uint8_t, 1)
323WIPEUP_TRANSITION(16, uint16_t, 2)
324
325#define WIPEDOWN_TRANSITION(name, type, div) \
326static void wipedown##name##_transition(AVFilterContext *ctx, \
327 const AVFrame *a, const AVFrame *b, AVFrame *out, \
328 float progress, \
329 int slice_start, int slice_end, int jobnr) \
330{ \
331 XFadeContext *s = ctx->priv; \
332 const int height = slice_end - slice_start; \
333 const int z = out->height * (1.f - progress); \
334 \
335 for (int p = 0; p < s->nb_planes; p++) { \
336 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
337 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
338 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
339 \
340 for (int y = 0; y < height; y++) { \
341 for (int x = 0; x < out->width; x++) { \
342 dst[x] = slice_start + y > z ? xf0[x] : xf1[x]; \
343 } \
344 \
345 dst += out->linesize[p] / div; \
346 xf0 += a->linesize[p] / div; \
347 xf1 += b->linesize[p] / div; \
348 } \
349 } \
350}
351
352WIPEDOWN_TRANSITION(8, uint8_t, 1)
353WIPEDOWN_TRANSITION(16, uint16_t, 2)
354
355#define SLIDELEFT_TRANSITION(name, type, div) \
356static void slideleft##name##_transition(AVFilterContext *ctx, \
357 const AVFrame *a, const AVFrame *b, AVFrame *out, \
358 float progress, \
359 int slice_start, int slice_end, int jobnr) \
360{ \
361 XFadeContext *s = ctx->priv; \
362 const int height = slice_end - slice_start; \
363 const int width = out->width; \
364 const int z = -progress * width; \
365 \
366 for (int p = 0; p < s->nb_planes; p++) { \
367 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
368 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
369 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
370 \
371 for (int y = 0; y < height; y++) { \
372 for (int x = 0; x < width; x++) { \
373 const int zx = z + x; \
374 const int zz = zx % width + width * (zx < 0); \
375 dst[x] = (zx > 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
376 } \
377 \
378 dst += out->linesize[p] / div; \
379 xf0 += a->linesize[p] / div; \
380 xf1 += b->linesize[p] / div; \
381 } \
382 } \
383}
384
385SLIDELEFT_TRANSITION(8, uint8_t, 1)
386SLIDELEFT_TRANSITION(16, uint16_t, 2)
387
388#define SLIDERIGHT_TRANSITION(name, type, div) \
389static void slideright##name##_transition(AVFilterContext *ctx, \
390 const AVFrame *a, const AVFrame *b, AVFrame *out, \
391 float progress, \
392 int slice_start, int slice_end, int jobnr) \
393{ \
394 XFadeContext *s = ctx->priv; \
395 const int height = slice_end - slice_start; \
396 const int width = out->width; \
397 const int z = progress * width; \
398 \
399 for (int p = 0; p < s->nb_planes; p++) { \
400 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
401 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
402 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
403 \
404 for (int y = 0; y < height; y++) { \
405 for (int x = 0; x < out->width; x++) { \
406 const int zx = z + x; \
407 const int zz = zx % width + width * (zx < 0); \
408 dst[x] = (zx > 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
409 } \
410 \
411 dst += out->linesize[p] / div; \
412 xf0 += a->linesize[p] / div; \
413 xf1 += b->linesize[p] / div; \
414 } \
415 } \
416}
417
418SLIDERIGHT_TRANSITION(8, uint8_t, 1)
419SLIDERIGHT_TRANSITION(16, uint16_t, 2)
420
421#define SLIDEUP_TRANSITION(name, type, div) \
422static void slideup##name##_transition(AVFilterContext *ctx, \
423 const AVFrame *a, const AVFrame *b, AVFrame *out, \
424 float progress, \
425 int slice_start, int slice_end, int jobnr) \
426{ \
427 XFadeContext *s = ctx->priv; \
428 const int height = out->height; \
429 const int z = -progress * height; \
430 \
431 for (int p = 0; p < s->nb_planes; p++) { \
432 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
433 \
434 for (int y = slice_start; y < slice_end; y++) { \
435 const int zy = z + y; \
436 const int zz = zy % height + height * (zy < 0); \
437 const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
438 const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
439 \
440 for (int x = 0; x < out->width; x++) { \
441 dst[x] = (zy > 0) && (zy < height) ? xf1[x] : xf0[x]; \
442 } \
443 \
444 dst += out->linesize[p] / div; \
445 } \
446 } \
447}
448
449SLIDEUP_TRANSITION(8, uint8_t, 1)
450SLIDEUP_TRANSITION(16, uint16_t, 2)
451
452#define SLIDEDOWN_TRANSITION(name, type, div) \
453static void slidedown##name##_transition(AVFilterContext *ctx, \
454 const AVFrame *a, const AVFrame *b, AVFrame *out, \
455 float progress, \
456 int slice_start, int slice_end, int jobnr) \
457{ \
458 XFadeContext *s = ctx->priv; \
459 const int height = out->height; \
460 const int z = progress * height; \
461 \
462 for (int p = 0; p < s->nb_planes; p++) { \
463 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
464 \
465 for (int y = slice_start; y < slice_end; y++) { \
466 const int zy = z + y; \
467 const int zz = zy % height + height * (zy < 0); \
468 const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
469 const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
470 \
471 for (int x = 0; x < out->width; x++) { \
472 dst[x] = (zy > 0) && (zy < height) ? xf1[x] : xf0[x]; \
473 } \
474 \
475 dst += out->linesize[p] / div; \
476 } \
477 } \
478}
479
480SLIDEDOWN_TRANSITION(8, uint8_t, 1)
481SLIDEDOWN_TRANSITION(16, uint16_t, 2)
482
483#define CIRCLECROP_TRANSITION(name, type, div) \
484static void circlecrop##name##_transition(AVFilterContext *ctx, \
485 const AVFrame *a, const AVFrame *b, AVFrame *out, \
486 float progress, \
487 int slice_start, int slice_end, int jobnr) \
488{ \
489 XFadeContext *s = ctx->priv; \
490 const int width = out->width; \
491 const int height = out->height; \
492 float z = powf(2.f * fabsf(progress - 0.5f), 3.f) * hypotf(width/2, height/2); \
493 \
494 for (int p = 0; p < s->nb_planes; p++) { \
495 const int bg = s->black[p]; \
496 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
497 \
498 for (int y = slice_start; y < slice_end; y++) { \
499 const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
500 const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
501 \
502 for (int x = 0; x < width; x++) { \
503 float dist = hypotf(x - width / 2, y - height / 2); \
504 int val = progress < 0.5f ? xf1[x] : xf0[x]; \
505 dst[x] = (z < dist) ? bg : val; \
506 } \
507 \
508 dst += out->linesize[p] / div; \
509 } \
510 } \
511}
512
513CIRCLECROP_TRANSITION(8, uint8_t, 1)
514CIRCLECROP_TRANSITION(16, uint16_t, 2)
515
516#define RECTCROP_TRANSITION(name, type, div) \
517static void rectcrop##name##_transition(AVFilterContext *ctx, \
518 const AVFrame *a, const AVFrame *b, AVFrame *out, \
519 float progress, \
520 int slice_start, int slice_end, int jobnr) \
521{ \
522 XFadeContext *s = ctx->priv; \
523 const int width = out->width; \
524 const int height = out->height; \
525 int zh = fabsf(progress - 0.5f) * height; \
526 int zw = fabsf(progress - 0.5f) * width; \
527 \
528 for (int p = 0; p < s->nb_planes; p++) { \
529 const int bg = s->black[p]; \
530 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
531 \
532 for (int y = slice_start; y < slice_end; y++) { \
533 const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
534 const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
535 \
536 for (int x = 0; x < width; x++) { \
537 int dist = FFABS(x - width / 2) < zw && \
538 FFABS(y - height / 2) < zh; \
539 int val = progress < 0.5f ? xf1[x] : xf0[x]; \
540 dst[x] = !dist ? bg : val; \
541 } \
542 \
543 dst += out->linesize[p] / div; \
544 } \
545 } \
546}
547
548RECTCROP_TRANSITION(8, uint8_t, 1)
549RECTCROP_TRANSITION(16, uint16_t, 2)
550
551#define DISTANCE_TRANSITION(name, type, div) \
552static void distance##name##_transition(AVFilterContext *ctx, \
553 const AVFrame *a, const AVFrame *b, AVFrame *out, \
554 float progress, \
555 int slice_start, int slice_end, int jobnr) \
556{ \
557 XFadeContext *s = ctx->priv; \
558 const int width = out->width; \
559 const float max = s->max_value; \
560 \
561 for (int y = slice_start; y < slice_end; y++) { \
562 for (int x = 0; x < width; x++) { \
563 float dist = 0.f; \
564 for (int p = 0; p < s->nb_planes; p++) { \
565 const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
566 const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
567 \
568 dist += (xf0[x] / max - xf1[x] / max) * \
569 (xf0[x] / max - xf1[x] / max); \
570 } \
571 \
572 dist = sqrtf(dist) <= progress; \
573 for (int p = 0; p < s->nb_planes; p++) { \
574 const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
575 const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
576 type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
577 dst[x] = mix(mix(xf0[x], xf1[x], dist), xf1[x], progress); \
578 } \
579 } \
580 } \
581}
582
583DISTANCE_TRANSITION(8, uint8_t, 1)
584DISTANCE_TRANSITION(16, uint16_t, 2)
585
586#define FADEBLACK_TRANSITION(name, type, div) \
587static void fadeblack##name##_transition(AVFilterContext *ctx, \
588 const AVFrame *a, const AVFrame *b, AVFrame *out, \
589 float progress, \
590 int slice_start, int slice_end, int jobnr) \
591{ \
592 XFadeContext *s = ctx->priv; \
593 const int height = slice_end - slice_start; \
594 const float phase = 0.2f; \
595 \
596 for (int p = 0; p < s->nb_planes; p++) { \
597 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
598 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
599 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
600 const int bg = s->black[p]; \
601 \
602 for (int y = 0; y < height; y++) { \
603 for (int x = 0; x < out->width; x++) { \
604 dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
605 mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
606 progress); \
607 } \
608 \
609 dst += out->linesize[p] / div; \
610 xf0 += a->linesize[p] / div; \
611 xf1 += b->linesize[p] / div; \
612 } \
613 } \
614}
615
616FADEBLACK_TRANSITION(8, uint8_t, 1)
617FADEBLACK_TRANSITION(16, uint16_t, 2)
618
619#define FADEWHITE_TRANSITION(name, type, div) \
620static void fadewhite##name##_transition(AVFilterContext *ctx, \
621 const AVFrame *a, const AVFrame *b, AVFrame *out, \
622 float progress, \
623 int slice_start, int slice_end, int jobnr) \
624{ \
625 XFadeContext *s = ctx->priv; \
626 const int height = slice_end - slice_start; \
627 const float phase = 0.2f; \
628 \
629 for (int p = 0; p < s->nb_planes; p++) { \
630 const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
631 const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
632 type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
633 const int bg = s->white[p]; \
634 \
635 for (int y = 0; y < height; y++) { \
636 for (int x = 0; x < out->width; x++) { \
637 dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
638 mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
639 progress); \
640 } \
641 \
642 dst += out->linesize[p] / div; \
643 xf0 += a->linesize[p] / div; \
644 xf1 += b->linesize[p] / div; \
645 } \
646 } \
647}
648
649FADEWHITE_TRANSITION(8, uint8_t, 1)
650FADEWHITE_TRANSITION(16, uint16_t, 2)
651
652static inline double getpix(void *priv, double x, double y, int plane, int nb)
653{
654 XFadeContext *s = priv;
655 AVFrame *in = s->xf[nb];
656 const uint8_t *src = in->data[FFMIN(plane, s->nb_planes - 1)];
657 int linesize = in->linesize[FFMIN(plane, s->nb_planes - 1)];
658 const int w = in->width;
659 const int h = in->height;
660
661 int xi, yi;
662
663 xi = av_clipd(x, 0, w - 1);
664 yi = av_clipd(y, 0, h - 1);
665
666 if (s->depth > 8) {
667 const uint16_t *src16 = (const uint16_t*)src;
668
669 linesize /= 2;
670 return src16[xi + yi * linesize];
671 } else {
672 return src[xi + yi * linesize];
673 }
674}
675
676static double a0(void *priv, double x, double y) { return getpix(priv, x, y, 0, 0); }
677static double a1(void *priv, double x, double y) { return getpix(priv, x, y, 1, 0); }
678static double a2(void *priv, double x, double y) { return getpix(priv, x, y, 2, 0); }
679static double a3(void *priv, double x, double y) { return getpix(priv, x, y, 3, 0); }
680
681static double b0(void *priv, double x, double y) { return getpix(priv, x, y, 0, 1); }
682static double b1(void *priv, double x, double y) { return getpix(priv, x, y, 1, 1); }
683static double b2(void *priv, double x, double y) { return getpix(priv, x, y, 2, 1); }
684static double b3(void *priv, double x, double y) { return getpix(priv, x, y, 3, 1); }
685
686static int config_output(AVFilterLink *outlink)
687{
688 AVFilterContext *ctx = outlink->src;
689 AVFilterLink *inlink0 = ctx->inputs[0];
690 AVFilterLink *inlink1 = ctx->inputs[1];
691 XFadeContext *s = ctx->priv;
692 const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink0->format);
693 int is_rgb;
694
695 if (inlink0->format != inlink1->format) {
696 av_log(ctx, AV_LOG_ERROR, "inputs must be of same pixel format\n");
697 return AVERROR(EINVAL);
698 }
699 if (inlink0->w != inlink1->w || inlink0->h != inlink1->h) {
700 av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
701 "(size %dx%d) do not match the corresponding "
702 "second input link %s parameters (size %dx%d)\n",
703 ctx->input_pads[0].name, inlink0->w, inlink0->h,
704 ctx->input_pads[1].name, inlink1->w, inlink1->h);
705 return AVERROR(EINVAL);
706 }
707
708 if (inlink0->time_base.num != inlink1->time_base.num ||
709 inlink0->time_base.den != inlink1->time_base.den) {
710 av_log(ctx, AV_LOG_ERROR, "First input link %s timebase "
711 "(%d/%d) do not match the corresponding "
712 "second input link %s timebase (%d/%d)\n",
713 ctx->input_pads[0].name, inlink0->time_base.num, inlink0->time_base.den,
714 ctx->input_pads[1].name, inlink1->time_base.num, inlink1->time_base.den);
715 return AVERROR(EINVAL);
716 }
717
718 outlink->w = inlink0->w;
719 outlink->h = inlink0->h;
720 outlink->time_base = inlink0->time_base;
721 outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
722 outlink->frame_rate = inlink0->frame_rate;
723
724 s->depth = pix_desc->comp[0].depth;
725 is_rgb = !!(pix_desc->flags & AV_PIX_FMT_FLAG_RGB);
726 s->nb_planes = av_pix_fmt_count_planes(inlink0->format);
727 s->max_value = (1 << s->depth) - 1;
728 s->black[0] = 0;
729 s->black[1] = s->black[2] = is_rgb ? 0 : s->max_value / 2;
730 s->black[3] = s->max_value;
731 s->white[0] = s->white[3] = s->max_value;
732 s->white[1] = s->white[2] = is_rgb ? s->max_value : s->max_value / 2;
733
734 s->first_pts = s->last_pts = s->pts = AV_NOPTS_VALUE;
735
736 if (s->duration)
737 s->duration_pts = av_rescale_q(s->duration, AV_TIME_BASE_Q, outlink->time_base);
738 if (s->offset)
739 s->offset_pts = av_rescale_q(s->offset, AV_TIME_BASE_Q, outlink->time_base);
740
741 switch (s->transition) {
742 case CUSTOM: s->transitionf = s->depth <= 8 ? custom8_transition : custom16_transition; break;
743 case FADE: s->transitionf = s->depth <= 8 ? fade8_transition : fade16_transition; break;
744 case WIPELEFT: s->transitionf = s->depth <= 8 ? wipeleft8_transition : wipeleft16_transition; break;
745 case WIPERIGHT: s->transitionf = s->depth <= 8 ? wiperight8_transition : wiperight16_transition; break;
746 case WIPEUP: s->transitionf = s->depth <= 8 ? wipeup8_transition : wipeup16_transition; break;
747 case WIPEDOWN: s->transitionf = s->depth <= 8 ? wipedown8_transition : wipedown16_transition; break;
748 case SLIDELEFT: s->transitionf = s->depth <= 8 ? slideleft8_transition : slideleft16_transition; break;
749 case SLIDERIGHT: s->transitionf = s->depth <= 8 ? slideright8_transition : slideright16_transition; break;
750 case SLIDEUP: s->transitionf = s->depth <= 8 ? slideup8_transition : slideup16_transition; break;
751 case SLIDEDOWN: s->transitionf = s->depth <= 8 ? slidedown8_transition : slidedown16_transition; break;
752 case CIRCLECROP: s->transitionf = s->depth <= 8 ? circlecrop8_transition : circlecrop16_transition; break;
753 case RECTCROP: s->transitionf = s->depth <= 8 ? rectcrop8_transition : rectcrop16_transition; break;
754 case DISTANCE: s->transitionf = s->depth <= 8 ? distance8_transition : distance16_transition; break;
755 case FADEBLACK: s->transitionf = s->depth <= 8 ? fadeblack8_transition : fadeblack16_transition; break;
756 case FADEWHITE: s->transitionf = s->depth <= 8 ? fadewhite8_transition : fadewhite16_transition; break;
757 }
758
759 if (s->transition == CUSTOM) {
760 static const char *const func2_names[] = {
761 "a0", "a1", "a2", "a3",
762 "b0", "b1", "b2", "b3",
763 NULL
764 };
765 double (*func2[])(void *, double, double) = {
766 a0, a1, a2, a3,
767 b0, b1, b2, b3,
768 NULL };
769 int ret;
770
771 if (!s->custom_str)
772 return AVERROR(EINVAL);
773 ret = av_expr_parse(&s->e, s->custom_str, var_names,
774 NULL, NULL, func2_names, func2, 0, ctx);
775 if (ret < 0)
776 return ret;
777 }
778
779 return 0;
780}
781
782static int xfade_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
783{
784 XFadeContext *s = ctx->priv;
785 AVFilterLink *outlink = ctx->outputs[0];
786 ThreadData *td = arg;
787 int slice_start = (outlink->h * jobnr ) / nb_jobs;
788 int slice_end = (outlink->h * (jobnr+1)) / nb_jobs;
789
790 s->transitionf(ctx, td->xf[0], td->xf[1], td->out, td->progress, slice_start, slice_end, jobnr);
791
792 return 0;
793}
794
795static int xfade_frame(AVFilterContext *ctx, AVFrame *a, AVFrame *b)
796{
797 XFadeContext *s = ctx->priv;
798 AVFilterLink *outlink = ctx->outputs[0];
799 float progress = av_clipf(1.f - ((float)(s->pts - s->first_pts - s->offset_pts) / s->duration_pts), 0.f, 1.f);
800 ThreadData td;
801 AVFrame *out;
802
803 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
804 if (!out)
805 return AVERROR(ENOMEM);
806
807 td.xf[0] = a, td.xf[1] = b, td.out = out, td.progress = progress;
808 ctx->internal->execute(ctx, xfade_slice, &td, NULL, FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
809
810 out->pts = s->pts;
811
812 return ff_filter_frame(outlink, out);
813}
814
815static int xfade_activate(AVFilterContext *ctx)
816{
817 XFadeContext *s = ctx->priv;
818 AVFilterLink *outlink = ctx->outputs[0];
819 AVFrame *in = NULL;
820 int ret = 0, status;
821 int64_t pts;
822
823 FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, ctx);
824
825 if (s->xfade_is_over) {
826 ret = ff_inlink_consume_frame(ctx->inputs[1], &in);
827 if (ret < 0) {
828 return ret;
829 } else if (ff_inlink_acknowledge_status(ctx->inputs[1], &status, &pts)) {
830 ff_outlink_set_status(outlink, status, s->pts);
831 return 0;
832 } else if (!ret) {
833 if (ff_outlink_frame_wanted(outlink)) {
834 ff_inlink_request_frame(ctx->inputs[1]);
835 return 0;
836 }
837 } else {
838 in->pts = (in->pts - s->last_pts) + s->pts;
839 return ff_filter_frame(outlink, in);
840 }
841 }
842
843 if (ff_inlink_queued_frames(ctx->inputs[0]) > 0) {
844 s->xf[0] = ff_inlink_peek_frame(ctx->inputs[0], 0);
845 if (s->xf[0]) {
846 if (s->first_pts == AV_NOPTS_VALUE) {
847 s->first_pts = s->xf[0]->pts;
848 }
849 s->pts = s->xf[0]->pts;
850 if (s->first_pts + s->offset_pts > s->xf[0]->pts) {
851 s->xf[0] = NULL;
852 s->need_second = 0;
853 ff_inlink_consume_frame(ctx->inputs[0], &in);
854 return ff_filter_frame(outlink, in);
855 }
856
857 s->need_second = 1;
858 }
859 }
860
861 if (s->xf[0] && ff_inlink_queued_frames(ctx->inputs[1]) > 0) {
862 ff_inlink_consume_frame(ctx->inputs[0], &s->xf[0]);
863 ff_inlink_consume_frame(ctx->inputs[1], &s->xf[1]);
864
865 s->last_pts = s->xf[1]->pts;
866 s->pts = s->xf[0]->pts;
867 if (s->xf[0]->pts - (s->first_pts + s->offset_pts) > s->duration_pts)
868 s->xfade_is_over = 1;
869 ret = xfade_frame(ctx, s->xf[0], s->xf[1]);
870 av_frame_free(&s->xf[0]);
871 av_frame_free(&s->xf[1]);
872 return ret;
873 }
874
875 if (ff_inlink_queued_frames(ctx->inputs[0]) > 0 &&
876 ff_inlink_queued_frames(ctx->inputs[1]) > 0) {
877 ff_filter_set_ready(ctx, 100);
878 return 0;
879 }
880
881 if (ff_outlink_frame_wanted(outlink)) {
882 if (!s->eof[0] && ff_outlink_get_status(ctx->inputs[0])) {
883 s->eof[0] = 1;
884 s->xfade_is_over = 1;
885 }
886 if (!s->eof[1] && ff_outlink_get_status(ctx->inputs[1])) {
887 s->eof[1] = 1;
888 }
889 if (!s->eof[0] && !s->xf[0])
890 ff_inlink_request_frame(ctx->inputs[0]);
891 if (!s->eof[1] && (s->need_second || s->eof[0]))
892 ff_inlink_request_frame(ctx->inputs[1]);
893 if (s->eof[0] && s->eof[1] && (
894 ff_inlink_queued_frames(ctx->inputs[0]) <= 0 ||
895 ff_inlink_queued_frames(ctx->inputs[1]) <= 0))
896 ff_outlink_set_status(outlink, AVERROR_EOF, AV_NOPTS_VALUE);
897 return 0;
898 }
899
900 return FFERROR_NOT_READY;
901}
902
903static const AVFilterPad xfade_inputs[] = {
904 {
905 .name = "main",
906 .type = AVMEDIA_TYPE_VIDEO,
907 },
908 {
909 .name = "xfade",
910 .type = AVMEDIA_TYPE_VIDEO,
911 },
912 { NULL }
913};
914
915static const AVFilterPad xfade_outputs[] = {
916 {
917 .name = "default",
918 .type = AVMEDIA_TYPE_VIDEO,
919 .config_props = config_output,
920 },
921 { NULL }
922};
923
924AVFilter ff_vf_xfade = {
925 .name = "xfade",
926 .description = NULL_IF_CONFIG_SMALL("Cross fade one video with another video."),
927 .priv_size = sizeof(XFadeContext),
928 .priv_class = &xfade_class,
929 .query_formats = query_formats,
930 .activate = xfade_activate,
931 .uninit = uninit,
932 .inputs = xfade_inputs,
933 .outputs = xfade_outputs,
934 .flags = AVFILTER_FLAG_SLICE_THREADS,
935};

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t