国道317线（西藏境内）丁青至斜拉山公路整治改建

Line	Branch	Exec	Source
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/eval.h"
22			#include "libavutil/opt.h"
23			#include "libavutil/pixdesc.h"
24			#include "libavutil/pixfmt.h"
25			#include "avfilter.h"
26			#include "filters.h"
27			#include "video.h"
28
29			enum XFadeTransitions {
30			CUSTOM = -1,
31			FADE,
32			WIPELEFT,
33			WIPERIGHT,
34			WIPEUP,
35			WIPEDOWN,
36			SLIDELEFT,
37			SLIDERIGHT,
38			SLIDEUP,
39			SLIDEDOWN,
40			CIRCLECROP,
41			RECTCROP,
42			DISTANCE,
43			FADEBLACK,
44			FADEWHITE,
45			RADIAL,
46			SMOOTHLEFT,
47			SMOOTHRIGHT,
48			SMOOTHUP,
49			SMOOTHDOWN,
50			CIRCLEOPEN,
51			CIRCLECLOSE,
52			VERTOPEN,
53			VERTCLOSE,
54			HORZOPEN,
55			HORZCLOSE,
56			DISSOLVE,
57			PIXELIZE,
58			DIAGTL,
59			DIAGTR,
60			DIAGBL,
61			DIAGBR,
62			HLSLICE,
63			HRSLICE,
64			VUSLICE,
65			VDSLICE,
66			HBLUR,
67			FADEGRAYS,
68			WIPETL,
69			WIPETR,
70			WIPEBL,
71			WIPEBR,
72			SQUEEZEH,
73			SQUEEZEV,
74			ZOOMIN,
75			FADEFAST,
76			FADESLOW,
77			HLWIND,
78			HRWIND,
79			VUWIND,
80			VDWIND,
81			COVERLEFT,
82			COVERRIGHT,
83			COVERUP,
84			COVERDOWN,
85			REVEALLEFT,
86			REVEALRIGHT,
87			REVEALUP,
88			REVEALDOWN,
89			NB_TRANSITIONS,
90			};
91
92			typedef struct XFadeContext {
93			const AVClass *class;
94
95			int transition;
96			int64_t duration;
97			int64_t offset;
98			char *custom_str;
99
100			int nb_planes;
101			int depth;
102			int is_rgb;
103
104			// PTS when the fade should start (in first inputs timebase)
105			int64_t start_pts;
106
107			// PTS offset between first and second input
108			int64_t inputs_offset_pts;
109
110			// Duration of the transition
111			int64_t duration_pts;
112
113			// Current PTS of the first input
114			int64_t pts;
115
116			// If frames are currently just passed through unmodified,
117			// like before and after the actual transition.
118			int passthrough;
119
120			int status[2];
121			AVFrame *xf[2];
122			int max_value;
123			uint16_t black[4];
124			uint16_t white[4];
125
126			void (*transitionf)(AVFilterContext *ctx, const AVFrame *a, const AVFrame *b, AVFrame *out, float progress,
127			int slice_start, int slice_end, int jobnr);
128
129			AVExpr *e;
130			} XFadeContext;
131
132			static const char *const var_names[] = { "X", "Y", "W", "H", "A", "B", "PLANE", "P", NULL };
133			enum { VAR_X, VAR_Y, VAR_W, VAR_H, VAR_A, VAR_B, VAR_PLANE, VAR_PROGRESS, VAR_VARS_NB };
134
135			typedef struct ThreadData {
136			const AVFrame *xf[2];
137			AVFrame *out;
138			float progress;
139			} ThreadData;
140
141			static const enum AVPixelFormat pix_fmts[] = {
142			AV_PIX_FMT_YUVA444P,
143			AV_PIX_FMT_YUVJ444P,
144			AV_PIX_FMT_YUV444P,
145			AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
146			AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_GBRP9,
147			AV_PIX_FMT_YUV444P10,
148			AV_PIX_FMT_YUVA444P10,
149			AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GRAY10,
150			AV_PIX_FMT_YUV444P12,
151			AV_PIX_FMT_YUVA444P12,
152			AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GRAY12,
153			AV_PIX_FMT_YUV444P14, AV_PIX_FMT_GBRP14,
154			AV_PIX_FMT_YUV444P16,
155			AV_PIX_FMT_YUVA444P16,
156			AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,
157			AV_PIX_FMT_NONE
158			};
159
160		✗	static av_cold void uninit(AVFilterContext *ctx)
161			{
162		✗	XFadeContext *s = ctx->priv;
163
164		✗	av_expr_free(s->e);
165		✗	}
166
167			#define OFFSET(x) offsetof(XFadeContext, x)
168			#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
169
170			static const AVOption xfade_options[] = {
171			{ "transition", "set cross fade transition", OFFSET(transition), AV_OPT_TYPE_INT, {.i64=FADE}, -1, NB_TRANSITIONS-1, FLAGS, .unit = "transition" },
172			{ "custom", "custom transition", 0, AV_OPT_TYPE_CONST, {.i64=CUSTOM}, 0, 0, FLAGS, .unit = "transition" },
173			{ "fade", "fade transition", 0, AV_OPT_TYPE_CONST, {.i64=FADE}, 0, 0, FLAGS, .unit = "transition" },
174			{ "wipeleft", "wipe left transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPELEFT}, 0, 0, FLAGS, .unit = "transition" },
175			{ "wiperight", "wipe right transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPERIGHT}, 0, 0, FLAGS, .unit = "transition" },
176			{ "wipeup", "wipe up transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEUP}, 0, 0, FLAGS, .unit = "transition" },
177			{ "wipedown", "wipe down transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEDOWN}, 0, 0, FLAGS, .unit = "transition" },
178			{ "slideleft", "slide left transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDELEFT}, 0, 0, FLAGS, .unit = "transition" },
179			{ "slideright", "slide right transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDERIGHT}, 0, 0, FLAGS, .unit = "transition" },
180			{ "slideup", "slide up transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDEUP}, 0, 0, FLAGS, .unit = "transition" },
181			{ "slidedown", "slide down transition", 0, AV_OPT_TYPE_CONST, {.i64=SLIDEDOWN}, 0, 0, FLAGS, .unit = "transition" },
182			{ "circlecrop", "circle crop transition", 0, AV_OPT_TYPE_CONST, {.i64=CIRCLECROP}, 0, 0, FLAGS, .unit = "transition" },
183			{ "rectcrop", "rect crop transition", 0, AV_OPT_TYPE_CONST, {.i64=RECTCROP}, 0, 0, FLAGS, .unit = "transition" },
184			{ "distance", "distance transition", 0, AV_OPT_TYPE_CONST, {.i64=DISTANCE}, 0, 0, FLAGS, .unit = "transition" },
185			{ "fadeblack", "fadeblack transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEBLACK}, 0, 0, FLAGS, .unit = "transition" },
186			{ "fadewhite", "fadewhite transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEWHITE}, 0, 0, FLAGS, .unit = "transition" },
187			{ "radial", "radial transition", 0, AV_OPT_TYPE_CONST, {.i64=RADIAL}, 0, 0, FLAGS, .unit = "transition" },
188			{ "smoothleft", "smoothleft transition", 0, AV_OPT_TYPE_CONST, {.i64=SMOOTHLEFT}, 0, 0, FLAGS, .unit = "transition" },
189			{ "smoothright","smoothright transition", 0, AV_OPT_TYPE_CONST, {.i64=SMOOTHRIGHT},0, 0, FLAGS, .unit = "transition" },
190			{ "smoothup", "smoothup transition", 0, AV_OPT_TYPE_CONST, {.i64=SMOOTHUP}, 0, 0, FLAGS, .unit = "transition" },
191			{ "smoothdown", "smoothdown transition", 0, AV_OPT_TYPE_CONST, {.i64=SMOOTHDOWN}, 0, 0, FLAGS, .unit = "transition" },
192			{ "circleopen", "circleopen transition", 0, AV_OPT_TYPE_CONST, {.i64=CIRCLEOPEN}, 0, 0, FLAGS, .unit = "transition" },
193			{ "circleclose","circleclose transition", 0, AV_OPT_TYPE_CONST, {.i64=CIRCLECLOSE},0, 0, FLAGS, .unit = "transition" },
194			{ "vertopen", "vert open transition", 0, AV_OPT_TYPE_CONST, {.i64=VERTOPEN}, 0, 0, FLAGS, .unit = "transition" },
195			{ "vertclose", "vert close transition", 0, AV_OPT_TYPE_CONST, {.i64=VERTCLOSE}, 0, 0, FLAGS, .unit = "transition" },
196			{ "horzopen", "horz open transition", 0, AV_OPT_TYPE_CONST, {.i64=HORZOPEN}, 0, 0, FLAGS, .unit = "transition" },
197			{ "horzclose", "horz close transition", 0, AV_OPT_TYPE_CONST, {.i64=HORZCLOSE}, 0, 0, FLAGS, .unit = "transition" },
198			{ "dissolve", "dissolve transition", 0, AV_OPT_TYPE_CONST, {.i64=DISSOLVE}, 0, 0, FLAGS, .unit = "transition" },
199			{ "pixelize", "pixelize transition", 0, AV_OPT_TYPE_CONST, {.i64=PIXELIZE}, 0, 0, FLAGS, .unit = "transition" },
200			{ "diagtl", "diag tl transition", 0, AV_OPT_TYPE_CONST, {.i64=DIAGTL}, 0, 0, FLAGS, .unit = "transition" },
201			{ "diagtr", "diag tr transition", 0, AV_OPT_TYPE_CONST, {.i64=DIAGTR}, 0, 0, FLAGS, .unit = "transition" },
202			{ "diagbl", "diag bl transition", 0, AV_OPT_TYPE_CONST, {.i64=DIAGBL}, 0, 0, FLAGS, .unit = "transition" },
203			{ "diagbr", "diag br transition", 0, AV_OPT_TYPE_CONST, {.i64=DIAGBR}, 0, 0, FLAGS, .unit = "transition" },
204			{ "hlslice", "hl slice transition", 0, AV_OPT_TYPE_CONST, {.i64=HLSLICE}, 0, 0, FLAGS, .unit = "transition" },
205			{ "hrslice", "hr slice transition", 0, AV_OPT_TYPE_CONST, {.i64=HRSLICE}, 0, 0, FLAGS, .unit = "transition" },
206			{ "vuslice", "vu slice transition", 0, AV_OPT_TYPE_CONST, {.i64=VUSLICE}, 0, 0, FLAGS, .unit = "transition" },
207			{ "vdslice", "vd slice transition", 0, AV_OPT_TYPE_CONST, {.i64=VDSLICE}, 0, 0, FLAGS, .unit = "transition" },
208			{ "hblur", "hblur transition", 0, AV_OPT_TYPE_CONST, {.i64=HBLUR}, 0, 0, FLAGS, .unit = "transition" },
209			{ "fadegrays", "fadegrays transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEGRAYS}, 0, 0, FLAGS, .unit = "transition" },
210			{ "wipetl", "wipe tl transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPETL}, 0, 0, FLAGS, .unit = "transition" },
211			{ "wipetr", "wipe tr transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPETR}, 0, 0, FLAGS, .unit = "transition" },
212			{ "wipebl", "wipe bl transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEBL}, 0, 0, FLAGS, .unit = "transition" },
213			{ "wipebr", "wipe br transition", 0, AV_OPT_TYPE_CONST, {.i64=WIPEBR}, 0, 0, FLAGS, .unit = "transition" },
214			{ "squeezeh", "squeeze h transition", 0, AV_OPT_TYPE_CONST, {.i64=SQUEEZEH}, 0, 0, FLAGS, .unit = "transition" },
215			{ "squeezev", "squeeze v transition", 0, AV_OPT_TYPE_CONST, {.i64=SQUEEZEV}, 0, 0, FLAGS, .unit = "transition" },
216			{ "zoomin", "zoom in transition", 0, AV_OPT_TYPE_CONST, {.i64=ZOOMIN}, 0, 0, FLAGS, .unit = "transition" },
217			{ "fadefast", "fast fade transition", 0, AV_OPT_TYPE_CONST, {.i64=FADEFAST}, 0, 0, FLAGS, .unit = "transition" },
218			{ "fadeslow", "slow fade transition", 0, AV_OPT_TYPE_CONST, {.i64=FADESLOW}, 0, 0, FLAGS, .unit = "transition" },
219			{ "hlwind", "hl wind transition", 0, AV_OPT_TYPE_CONST, {.i64=HLWIND}, 0, 0, FLAGS, .unit = "transition" },
220			{ "hrwind", "hr wind transition", 0, AV_OPT_TYPE_CONST, {.i64=HRWIND}, 0, 0, FLAGS, .unit = "transition" },
221			{ "vuwind", "vu wind transition", 0, AV_OPT_TYPE_CONST, {.i64=VUWIND}, 0, 0, FLAGS, .unit = "transition" },
222			{ "vdwind", "vd wind transition", 0, AV_OPT_TYPE_CONST, {.i64=VDWIND}, 0, 0, FLAGS, .unit = "transition" },
223			{ "coverleft", "cover left transition", 0, AV_OPT_TYPE_CONST, {.i64=COVERLEFT}, 0, 0, FLAGS, .unit = "transition" },
224			{ "coverright", "cover right transition", 0, AV_OPT_TYPE_CONST, {.i64=COVERRIGHT}, 0, 0, FLAGS, .unit = "transition" },
225			{ "coverup", "cover up transition", 0, AV_OPT_TYPE_CONST, {.i64=COVERUP}, 0, 0, FLAGS, .unit = "transition" },
226			{ "coverdown", "cover down transition", 0, AV_OPT_TYPE_CONST, {.i64=COVERDOWN}, 0, 0, FLAGS, .unit = "transition" },
227			{ "revealleft", "reveal left transition", 0, AV_OPT_TYPE_CONST, {.i64=REVEALLEFT}, 0, 0, FLAGS, .unit = "transition" },
228			{ "revealright","reveal right transition",0, AV_OPT_TYPE_CONST, {.i64=REVEALRIGHT},0, 0, FLAGS, .unit = "transition" },
229			{ "revealup", "reveal up transition", 0, AV_OPT_TYPE_CONST, {.i64=REVEALUP}, 0, 0, FLAGS, .unit = "transition" },
230			{ "revealdown", "reveal down transition", 0, AV_OPT_TYPE_CONST, {.i64=REVEALDOWN}, 0, 0, FLAGS, .unit = "transition" },
231			{ "duration", "set cross fade duration", OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64=1000000}, 0, 60000000, FLAGS },
232			{ "offset", "set cross fade start relative to first input stream", OFFSET(offset), AV_OPT_TYPE_DURATION, {.i64=0}, INT64_MIN, INT64_MAX, FLAGS },
233			{ "expr", "set expression for custom transition", OFFSET(custom_str), AV_OPT_TYPE_STRING, {.str=NULL}, 0, 0, FLAGS },
234			{ NULL }
235			};
236
237			AVFILTER_DEFINE_CLASS(xfade);
238
239			#define CUSTOM_TRANSITION(name, type, div) \
240			static void custom##name##_transition(AVFilterContext *ctx, \
241			const AVFrame *a, const AVFrame *b, AVFrame *out, \
242			float progress, \
243			int slice_start, int slice_end, int jobnr) \
244			{ \
245			XFadeContext *s = ctx->priv; \
246			const int height = slice_end - slice_start; \
247			const int width = out->width; \
248			\
249			double values[VAR_VARS_NB]; \
250			values[VAR_W] = width; \
251			values[VAR_H] = out->height; \
252			values[VAR_PROGRESS] = progress; \
253			\
254			for (int p = 0; p < s->nb_planes; p++) { \
255			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
256			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
257			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
258			\
259			values[VAR_PLANE] = p; \
260			\
261			for (int y = 0; y < height; y++) { \
262			values[VAR_Y] = slice_start + y; \
263			for (int x = 0; x < width; x++) { \
264			values[VAR_X] = x; \
265			values[VAR_A] = xf0[x]; \
266			values[VAR_B] = xf1[x]; \
267			dst[x] = av_expr_eval(s->e, values, s); \
268			} \
269			\
270			dst += out->linesize[p] / div; \
271			xf0 += a->linesize[p] / div; \
272			xf1 += b->linesize[p] / div; \
273			} \
274			} \
275			}
276
277		✗	CUSTOM_TRANSITION(8, uint8_t, 1)
278		✗	CUSTOM_TRANSITION(16, uint16_t, 2)
279
280		✗	static inline float mix(float a, float b, float mix)
281			{
282		✗	return a * mix + b * (1.f - mix);
283			}
284
285		✗	static inline float fract(float a)
286			{
287		✗	return a - floorf(a);
288			}
289
290		✗	static inline float smoothstep(float edge0, float edge1, float x)
291			{
292			float t;
293
294		✗	t = av_clipf((x - edge0) / (edge1 - edge0), 0.f, 1.f);
295
296		✗	return t * t * (3.f - 2.f * t);
297			}
298
299			#define FADE_TRANSITION(name, type, div) \
300			static void fade##name##_transition(AVFilterContext *ctx, \
301			const AVFrame *a, const AVFrame *b, AVFrame *out, \
302			float progress, \
303			int slice_start, int slice_end, int jobnr) \
304			{ \
305			XFadeContext *s = ctx->priv; \
306			const int height = slice_end - slice_start; \
307			const int width = out->width; \
308			\
309			for (int p = 0; p < s->nb_planes; p++) { \
310			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
311			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
312			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
313			\
314			for (int y = 0; y < height; y++) { \
315			for (int x = 0; x < width; x++) { \
316			dst[x] = mix(xf0[x], xf1[x], progress); \
317			} \
318			\
319			dst += out->linesize[p] / div; \
320			xf0 += a->linesize[p] / div; \
321			xf1 += b->linesize[p] / div; \
322			} \
323			} \
324			}
325
326		✗	FADE_TRANSITION(8, uint8_t, 1)
327		✗	FADE_TRANSITION(16, uint16_t, 2)
328
329			#define WIPELEFT_TRANSITION(name, type, div) \
330			static void wipeleft##name##_transition(AVFilterContext *ctx, \
331			const AVFrame *a, const AVFrame *b, AVFrame *out, \
332			float progress, \
333			int slice_start, int slice_end, int jobnr) \
334			{ \
335			XFadeContext *s = ctx->priv; \
336			const int height = slice_end - slice_start; \
337			const int width = out->width; \
338			const int z = width * progress; \
339			\
340			for (int p = 0; p < s->nb_planes; p++) { \
341			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
342			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
343			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
344			\
345			for (int y = 0; y < height; y++) { \
346			for (int x = 0; x < width; x++) { \
347			dst[x] = x > z ? xf1[x] : xf0[x]; \
348			} \
349			\
350			dst += out->linesize[p] / div; \
351			xf0 += a->linesize[p] / div; \
352			xf1 += b->linesize[p] / div; \
353			} \
354			} \
355			}
356
357		✗	WIPELEFT_TRANSITION(8, uint8_t, 1)
358		✗	WIPELEFT_TRANSITION(16, uint16_t, 2)
359
360			#define WIPERIGHT_TRANSITION(name, type, div) \
361			static void wiperight##name##_transition(AVFilterContext *ctx, \
362			const AVFrame *a, const AVFrame *b, AVFrame *out, \
363			float progress, \
364			int slice_start, int slice_end, int jobnr) \
365			{ \
366			XFadeContext *s = ctx->priv; \
367			const int height = slice_end - slice_start; \
368			const int width = out->width; \
369			const int z = width * (1.f - progress); \
370			\
371			for (int p = 0; p < s->nb_planes; p++) { \
372			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
373			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
374			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
375			\
376			for (int y = 0; y < height; y++) { \
377			for (int x = 0; x < width; x++) { \
378			dst[x] = x > z ? xf0[x] : xf1[x]; \
379			} \
380			\
381			dst += out->linesize[p] / div; \
382			xf0 += a->linesize[p] / div; \
383			xf1 += b->linesize[p] / div; \
384			} \
385			} \
386			}
387
388		✗	WIPERIGHT_TRANSITION(8, uint8_t, 1)
389		✗	WIPERIGHT_TRANSITION(16, uint16_t, 2)
390
391			#define WIPEUP_TRANSITION(name, type, div) \
392			static void wipeup##name##_transition(AVFilterContext *ctx, \
393			const AVFrame *a, const AVFrame *b, AVFrame *out, \
394			float progress, \
395			int slice_start, int slice_end, int jobnr) \
396			{ \
397			XFadeContext *s = ctx->priv; \
398			const int height = slice_end - slice_start; \
399			const int width = out->width; \
400			const int z = out->height * progress; \
401			\
402			for (int p = 0; p < s->nb_planes; p++) { \
403			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
404			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
405			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
406			\
407			for (int y = 0; y < height; y++) { \
408			for (int x = 0; x < width; x++) { \
409			dst[x] = slice_start + y > z ? xf1[x] : xf0[x]; \
410			} \
411			\
412			dst += out->linesize[p] / div; \
413			xf0 += a->linesize[p] / div; \
414			xf1 += b->linesize[p] / div; \
415			} \
416			} \
417			}
418
419		✗	WIPEUP_TRANSITION(8, uint8_t, 1)
420		✗	WIPEUP_TRANSITION(16, uint16_t, 2)
421
422			#define WIPEDOWN_TRANSITION(name, type, div) \
423			static void wipedown##name##_transition(AVFilterContext *ctx, \
424			const AVFrame *a, const AVFrame *b, AVFrame *out, \
425			float progress, \
426			int slice_start, int slice_end, int jobnr) \
427			{ \
428			XFadeContext *s = ctx->priv; \
429			const int height = slice_end - slice_start; \
430			const int width = out->width; \
431			const int z = out->height * (1.f - progress); \
432			\
433			for (int p = 0; p < s->nb_planes; p++) { \
434			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
435			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
436			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
437			\
438			for (int y = 0; y < height; y++) { \
439			for (int x = 0; x < width; x++) { \
440			dst[x] = slice_start + y > z ? xf0[x] : xf1[x]; \
441			} \
442			\
443			dst += out->linesize[p] / div; \
444			xf0 += a->linesize[p] / div; \
445			xf1 += b->linesize[p] / div; \
446			} \
447			} \
448			}
449
450		✗	WIPEDOWN_TRANSITION(8, uint8_t, 1)
451		✗	WIPEDOWN_TRANSITION(16, uint16_t, 2)
452
453			#define SLIDELEFT_TRANSITION(name, type, div) \
454			static void slideleft##name##_transition(AVFilterContext *ctx, \
455			const AVFrame *a, const AVFrame *b, AVFrame *out, \
456			float progress, \
457			int slice_start, int slice_end, int jobnr) \
458			{ \
459			XFadeContext *s = ctx->priv; \
460			const int height = slice_end - slice_start; \
461			const int width = out->width; \
462			const int z = -progress * width; \
463			\
464			for (int p = 0; p < s->nb_planes; p++) { \
465			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
466			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
467			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
468			\
469			for (int y = 0; y < height; y++) { \
470			for (int x = 0; x < width; x++) { \
471			const int zx = z + x; \
472			const int zz = zx % width + width * (zx < 0); \
473			dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
474			} \
475			\
476			dst += out->linesize[p] / div; \
477			xf0 += a->linesize[p] / div; \
478			xf1 += b->linesize[p] / div; \
479			} \
480			} \
481			}
482
483		✗	SLIDELEFT_TRANSITION(8, uint8_t, 1)
484		✗	SLIDELEFT_TRANSITION(16, uint16_t, 2)
485
486			#define SLIDERIGHT_TRANSITION(name, type, div) \
487			static void slideright##name##_transition(AVFilterContext *ctx, \
488			const AVFrame *a, const AVFrame *b, AVFrame *out, \
489			float progress, \
490			int slice_start, int slice_end, int jobnr) \
491			{ \
492			XFadeContext *s = ctx->priv; \
493			const int height = slice_end - slice_start; \
494			const int width = out->width; \
495			const int z = progress * width; \
496			\
497			for (int p = 0; p < s->nb_planes; p++) { \
498			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
499			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
500			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
501			\
502			for (int y = 0; y < height; y++) { \
503			for (int x = 0; x < width; x++) { \
504			const int zx = z + x; \
505			const int zz = zx % width + width * (zx < 0); \
506			dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
507			} \
508			\
509			dst += out->linesize[p] / div; \
510			xf0 += a->linesize[p] / div; \
511			xf1 += b->linesize[p] / div; \
512			} \
513			} \
514			}
515
516		✗	SLIDERIGHT_TRANSITION(8, uint8_t, 1)
517		✗	SLIDERIGHT_TRANSITION(16, uint16_t, 2)
518
519			#define SLIDEUP_TRANSITION(name, type, div) \
520			static void slideup##name##_transition(AVFilterContext *ctx, \
521			const AVFrame *a, const AVFrame *b, AVFrame *out, \
522			float progress, \
523			int slice_start, int slice_end, int jobnr) \
524			{ \
525			XFadeContext *s = ctx->priv; \
526			const int height = out->height; \
527			const int width = out->width; \
528			const int z = -progress * height; \
529			\
530			for (int p = 0; p < s->nb_planes; p++) { \
531			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
532			\
533			for (int y = slice_start; y < slice_end; y++) { \
534			const int zy = z + y; \
535			const int zz = zy % height + height * (zy < 0); \
536			const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
537			const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
538			\
539			for (int x = 0; x < width; x++) { \
540			dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
541			} \
542			\
543			dst += out->linesize[p] / div; \
544			} \
545			} \
546			}
547
548		✗	SLIDEUP_TRANSITION(8, uint8_t, 1)
549		✗	SLIDEUP_TRANSITION(16, uint16_t, 2)
550
551			#define SLIDEDOWN_TRANSITION(name, type, div) \
552			static void slidedown##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 height = out->height; \
559			const int width = out->width; \
560			const int z = progress * height; \
561			\
562			for (int p = 0; p < s->nb_planes; p++) { \
563			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
564			\
565			for (int y = slice_start; y < slice_end; y++) { \
566			const int zy = z + y; \
567			const int zz = zy % height + height * (zy < 0); \
568			const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
569			const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
570			\
571			for (int x = 0; x < width; x++) { \
572			dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
573			} \
574			\
575			dst += out->linesize[p] / div; \
576			} \
577			} \
578			}
579
580		✗	SLIDEDOWN_TRANSITION(8, uint8_t, 1)
581		✗	SLIDEDOWN_TRANSITION(16, uint16_t, 2)
582
583			#define CIRCLECROP_TRANSITION(name, type, div) \
584			static void circlecrop##name##_transition(AVFilterContext *ctx, \
585			const AVFrame *a, const AVFrame *b, AVFrame *out, \
586			float progress, \
587			int slice_start, int slice_end, int jobnr) \
588			{ \
589			XFadeContext *s = ctx->priv; \
590			const int width = out->width; \
591			const int height = out->height; \
592			float z = powf(2.f * fabsf(progress - 0.5f), 3.f) * hypotf(width/2, height/2); \
593			\
594			for (int p = 0; p < s->nb_planes; p++) { \
595			const int bg = s->black[p]; \
596			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
597			\
598			for (int y = slice_start; y < slice_end; y++) { \
599			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
600			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
601			\
602			for (int x = 0; x < width; x++) { \
603			float dist = hypotf(x - width / 2, y - height / 2); \
604			int val = progress < 0.5f ? xf1[x] : xf0[x]; \
605			dst[x] = (z < dist) ? bg : val; \
606			} \
607			\
608			dst += out->linesize[p] / div; \
609			} \
610			} \
611			}
612
613		✗	CIRCLECROP_TRANSITION(8, uint8_t, 1)
614		✗	CIRCLECROP_TRANSITION(16, uint16_t, 2)
615
616			#define RECTCROP_TRANSITION(name, type, div) \
617			static void rectcrop##name##_transition(AVFilterContext *ctx, \
618			const AVFrame *a, const AVFrame *b, AVFrame *out, \
619			float progress, \
620			int slice_start, int slice_end, int jobnr) \
621			{ \
622			XFadeContext *s = ctx->priv; \
623			const int width = out->width; \
624			const int height = out->height; \
625			int zh = fabsf(progress - 0.5f) * height; \
626			int zw = fabsf(progress - 0.5f) * width; \
627			\
628			for (int p = 0; p < s->nb_planes; p++) { \
629			const int bg = s->black[p]; \
630			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
631			\
632			for (int y = slice_start; y < slice_end; y++) { \
633			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
634			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
635			\
636			for (int x = 0; x < width; x++) { \
637			int dist = FFABS(x - width / 2) < zw && \
638			FFABS(y - height / 2) < zh; \
639			int val = progress < 0.5f ? xf1[x] : xf0[x]; \
640			dst[x] = !dist ? bg : val; \
641			} \
642			\
643			dst += out->linesize[p] / div; \
644			} \
645			} \
646			}
647
648		✗	RECTCROP_TRANSITION(8, uint8_t, 1)
649		✗	RECTCROP_TRANSITION(16, uint16_t, 2)
650
651			#define DISTANCE_TRANSITION(name, type, div) \
652			static void distance##name##_transition(AVFilterContext *ctx, \
653			const AVFrame *a, const AVFrame *b, AVFrame *out, \
654			float progress, \
655			int slice_start, int slice_end, int jobnr) \
656			{ \
657			XFadeContext *s = ctx->priv; \
658			const int width = out->width; \
659			const float max = s->max_value; \
660			\
661			for (int y = slice_start; y < slice_end; y++) { \
662			for (int x = 0; x < width; x++) { \
663			float dist = 0.f; \
664			for (int p = 0; p < s->nb_planes; p++) { \
665			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
666			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
667			\
668			dist += (xf0[x] / max - xf1[x] / max) * \
669			(xf0[x] / max - xf1[x] / max); \
670			} \
671			\
672			dist = sqrtf(dist) <= progress; \
673			for (int p = 0; p < s->nb_planes; p++) { \
674			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
675			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
676			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
677			dst[x] = mix(mix(xf0[x], xf1[x], dist), xf1[x], progress); \
678			} \
679			} \
680			} \
681			}
682
683		✗	DISTANCE_TRANSITION(8, uint8_t, 1)
684		✗	DISTANCE_TRANSITION(16, uint16_t, 2)
685
686			#define FADEBLACK_TRANSITION(name, type, div) \
687			static void fadeblack##name##_transition(AVFilterContext *ctx, \
688			const AVFrame *a, const AVFrame *b, AVFrame *out, \
689			float progress, \
690			int slice_start, int slice_end, int jobnr) \
691			{ \
692			XFadeContext *s = ctx->priv; \
693			const int height = slice_end - slice_start; \
694			const int width = out->width; \
695			const float phase = 0.2f; \
696			\
697			for (int p = 0; p < s->nb_planes; p++) { \
698			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
699			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
700			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
701			const int bg = s->black[p]; \
702			\
703			for (int y = 0; y < height; y++) { \
704			for (int x = 0; x < width; x++) { \
705			dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
706			mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
707			progress); \
708			} \
709			\
710			dst += out->linesize[p] / div; \
711			xf0 += a->linesize[p] / div; \
712			xf1 += b->linesize[p] / div; \
713			} \
714			} \
715			}
716
717		✗	FADEBLACK_TRANSITION(8, uint8_t, 1)
718		✗	FADEBLACK_TRANSITION(16, uint16_t, 2)
719
720			#define FADEWHITE_TRANSITION(name, type, div) \
721			static void fadewhite##name##_transition(AVFilterContext *ctx, \
722			const AVFrame *a, const AVFrame *b, AVFrame *out, \
723			float progress, \
724			int slice_start, int slice_end, int jobnr) \
725			{ \
726			XFadeContext *s = ctx->priv; \
727			const int height = slice_end - slice_start; \
728			const int width = out->width; \
729			const float phase = 0.2f; \
730			\
731			for (int p = 0; p < s->nb_planes; p++) { \
732			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
733			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
734			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
735			const int bg = s->white[p]; \
736			\
737			for (int y = 0; y < height; y++) { \
738			for (int x = 0; x < width; x++) { \
739			dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
740			mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
741			progress); \
742			} \
743			\
744			dst += out->linesize[p] / div; \
745			xf0 += a->linesize[p] / div; \
746			xf1 += b->linesize[p] / div; \
747			} \
748			} \
749			}
750
751		✗	FADEWHITE_TRANSITION(8, uint8_t, 1)
752		✗	FADEWHITE_TRANSITION(16, uint16_t, 2)
753
754			#define RADIAL_TRANSITION(name, type, div) \
755			static void radial##name##_transition(AVFilterContext *ctx, \
756			const AVFrame *a, const AVFrame *b, AVFrame *out, \
757			float progress, \
758			int slice_start, int slice_end, int jobnr) \
759			{ \
760			XFadeContext *s = ctx->priv; \
761			const int width = out->width; \
762			const int height = out->height; \
763			\
764			for (int y = slice_start; y < slice_end; y++) { \
765			for (int x = 0; x < width; x++) { \
766			const float smooth = atan2f(x - width / 2, y - height / 2) - \
767			(progress - 0.5f) * (M_PI * 2.5f); \
768			for (int p = 0; p < s->nb_planes; p++) { \
769			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
770			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
771			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
772			\
773			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
774			} \
775			} \
776			} \
777			}
778
779		✗	RADIAL_TRANSITION(8, uint8_t, 1)
780		✗	RADIAL_TRANSITION(16, uint16_t, 2)
781
782			#define SMOOTHLEFT_TRANSITION(name, type, div) \
783			static void smoothleft##name##_transition(AVFilterContext *ctx, \
784			const AVFrame *a, const AVFrame *b, AVFrame *out, \
785			float progress, \
786			int slice_start, int slice_end, int jobnr) \
787			{ \
788			XFadeContext *s = ctx->priv; \
789			const int width = out->width; \
790			const float w = width; \
791			\
792			for (int y = slice_start; y < slice_end; y++) { \
793			for (int x = 0; x < width; x++) { \
794			const float smooth = 1.f + x / w - progress * 2.f; \
795			\
796			for (int p = 0; p < s->nb_planes; p++) { \
797			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
798			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
799			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
800			\
801			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
802			} \
803			} \
804			} \
805			}
806
807		✗	SMOOTHLEFT_TRANSITION(8, uint8_t, 1)
808		✗	SMOOTHLEFT_TRANSITION(16, uint16_t, 2)
809
810			#define SMOOTHRIGHT_TRANSITION(name, type, div) \
811			static void smoothright##name##_transition(AVFilterContext *ctx, \
812			const AVFrame *a, const AVFrame *b, AVFrame *out, \
813			float progress, \
814			int slice_start, int slice_end, int jobnr) \
815			{ \
816			XFadeContext *s = ctx->priv; \
817			const int width = out->width; \
818			const float w = width; \
819			\
820			for (int y = slice_start; y < slice_end; y++) { \
821			for (int x = 0; x < width; x++) { \
822			const float smooth = 1.f + (w - 1 - x) / w - progress * 2.f; \
823			\
824			for (int p = 0; p < s->nb_planes; p++) { \
825			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
826			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
827			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
828			\
829			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
830			} \
831			} \
832			} \
833			}
834
835		✗	SMOOTHRIGHT_TRANSITION(8, uint8_t, 1)
836		✗	SMOOTHRIGHT_TRANSITION(16, uint16_t, 2)
837
838			#define SMOOTHUP_TRANSITION(name, type, div) \
839			static void smoothup##name##_transition(AVFilterContext *ctx, \
840			const AVFrame *a, const AVFrame *b, AVFrame *out, \
841			float progress, \
842			int slice_start, int slice_end, int jobnr) \
843			{ \
844			XFadeContext *s = ctx->priv; \
845			const int width = out->width; \
846			const float h = out->height; \
847			\
848			for (int y = slice_start; y < slice_end; y++) { \
849			const float smooth = 1.f + y / h - progress * 2.f; \
850			for (int x = 0; x < width; x++) { \
851			for (int p = 0; p < s->nb_planes; p++) { \
852			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
853			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
854			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
855			\
856			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
857			} \
858			} \
859			} \
860			}
861
862		✗	SMOOTHUP_TRANSITION(8, uint8_t, 1)
863		✗	SMOOTHUP_TRANSITION(16, uint16_t, 2)
864
865			#define SMOOTHDOWN_TRANSITION(name, type, div) \
866			static void smoothdown##name##_transition(AVFilterContext *ctx, \
867			const AVFrame *a, const AVFrame *b, AVFrame *out, \
868			float progress, \
869			int slice_start, int slice_end, int jobnr) \
870			{ \
871			XFadeContext *s = ctx->priv; \
872			const int width = out->width; \
873			const float h = out->height; \
874			\
875			for (int y = slice_start; y < slice_end; y++) { \
876			const float smooth = 1.f + (h - 1 - y) / h - progress * 2.f; \
877			for (int x = 0; x < width; x++) { \
878			for (int p = 0; p < s->nb_planes; p++) { \
879			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
880			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
881			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
882			\
883			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
884			} \
885			} \
886			} \
887			}
888
889		✗	SMOOTHDOWN_TRANSITION(8, uint8_t, 1)
890		✗	SMOOTHDOWN_TRANSITION(16, uint16_t, 2)
891
892			#define CIRCLEOPEN_TRANSITION(name, type, div) \
893			static void circleopen##name##_transition(AVFilterContext *ctx, \
894			const AVFrame *a, const AVFrame *b, AVFrame *out, \
895			float progress, \
896			int slice_start, int slice_end, int jobnr) \
897			{ \
898			XFadeContext *s = ctx->priv; \
899			const int width = out->width; \
900			const int height = out->height; \
901			const float z = hypotf(width / 2, height / 2); \
902			const float p = (progress - 0.5f) * 3.f; \
903			\
904			for (int y = slice_start; y < slice_end; y++) { \
905			for (int x = 0; x < width; x++) { \
906			const float smooth = hypotf(x - width / 2, y - height / 2) / z + p; \
907			for (int p = 0; p < s->nb_planes; p++) { \
908			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
909			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
910			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
911			\
912			dst[x] = mix(xf0[x], xf1[x], smoothstep(0.f, 1.f, smooth)); \
913			} \
914			} \
915			} \
916			}
917
918		✗	CIRCLEOPEN_TRANSITION(8, uint8_t, 1)
919		✗	CIRCLEOPEN_TRANSITION(16, uint16_t, 2)
920
921			#define CIRCLECLOSE_TRANSITION(name, type, div) \
922			static void circleclose##name##_transition(AVFilterContext *ctx, \
923			const AVFrame *a, const AVFrame *b, AVFrame *out, \
924			float progress, \
925			int slice_start, int slice_end, int jobnr) \
926			{ \
927			XFadeContext *s = ctx->priv; \
928			const int width = out->width; \
929			const int height = out->height; \
930			const float z = hypotf(width / 2, height / 2); \
931			const float p = (1.f - progress - 0.5f) * 3.f; \
932			\
933			for (int y = slice_start; y < slice_end; y++) { \
934			for (int x = 0; x < width; x++) { \
935			const float smooth = hypotf(x - width / 2, y - height / 2) / z + p; \
936			for (int p = 0; p < s->nb_planes; p++) { \
937			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
938			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
939			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
940			\
941			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
942			} \
943			} \
944			} \
945			}
946
947		✗	CIRCLECLOSE_TRANSITION(8, uint8_t, 1)
948		✗	CIRCLECLOSE_TRANSITION(16, uint16_t, 2)
949
950			#define VERTOPEN_TRANSITION(name, type, div) \
951			static void vertopen##name##_transition(AVFilterContext *ctx, \
952			const AVFrame *a, const AVFrame *b, AVFrame *out, \
953			float progress, \
954			int slice_start, int slice_end, int jobnr) \
955			{ \
956			XFadeContext *s = ctx->priv; \
957			const int width = out->width; \
958			const float w2 = out->width / 2.0; \
959			\
960			for (int y = slice_start; y < slice_end; y++) { \
961			for (int x = 0; x < width; x++) { \
962			const float smooth = 2.f - fabsf((x - w2) / w2) - progress * 2.f; \
963			for (int p = 0; p < s->nb_planes; p++) { \
964			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
965			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
966			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
967			\
968			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
969			} \
970			} \
971			} \
972			}
973
974		✗	VERTOPEN_TRANSITION(8, uint8_t, 1)
975		✗	VERTOPEN_TRANSITION(16, uint16_t, 2)
976
977			#define VERTCLOSE_TRANSITION(name, type, div) \
978			static void vertclose##name##_transition(AVFilterContext *ctx, \
979			const AVFrame *a, const AVFrame *b, AVFrame *out, \
980			float progress, \
981			int slice_start, int slice_end, int jobnr) \
982			{ \
983			XFadeContext *s = ctx->priv; \
984			const int nb_planes = s->nb_planes; \
985			const int width = out->width; \
986			const float w2 = out->width / 2.0; \
987			\
988			for (int y = slice_start; y < slice_end; y++) { \
989			for (int x = 0; x < width; x++) { \
990			const float smooth = 1.f + fabsf((x - w2) / w2) - progress * 2.f; \
991			for (int p = 0; p < nb_planes; p++) { \
992			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
993			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
994			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
995			\
996			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
997			} \
998			} \
999			} \
1000			}
1001
1002		✗	VERTCLOSE_TRANSITION(8, uint8_t, 1)
1003		✗	VERTCLOSE_TRANSITION(16, uint16_t, 2)
1004
1005			#define HORZOPEN_TRANSITION(name, type, div) \
1006			static void horzopen##name##_transition(AVFilterContext *ctx, \
1007			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1008			float progress, \
1009			int slice_start, int slice_end, int jobnr) \
1010			{ \
1011			XFadeContext *s = ctx->priv; \
1012			const int nb_planes = s->nb_planes; \
1013			const int width = out->width; \
1014			const float h2 = out->height / 2.0; \
1015			\
1016			for (int y = slice_start; y < slice_end; y++) { \
1017			const float smooth = 2.f - fabsf((y - h2) / h2) - progress * 2.f; \
1018			for (int x = 0; x < width; x++) { \
1019			for (int p = 0; p < nb_planes; p++) { \
1020			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1021			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1022			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1023			\
1024			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1025			} \
1026			} \
1027			} \
1028			}
1029
1030		✗	HORZOPEN_TRANSITION(8, uint8_t, 1)
1031		✗	HORZOPEN_TRANSITION(16, uint16_t, 2)
1032
1033			#define HORZCLOSE_TRANSITION(name, type, div) \
1034			static void horzclose##name##_transition(AVFilterContext *ctx, \
1035			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1036			float progress, \
1037			int slice_start, int slice_end, int jobnr) \
1038			{ \
1039			XFadeContext *s = ctx->priv; \
1040			const int nb_planes = s->nb_planes; \
1041			const int width = out->width; \
1042			const float h2 = out->height / 2.0; \
1043			\
1044			for (int y = slice_start; y < slice_end; y++) { \
1045			const float smooth = 1.f + fabsf((y - h2) / h2) - progress * 2.f; \
1046			for (int x = 0; x < width; x++) { \
1047			for (int p = 0; p < nb_planes; p++) { \
1048			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1049			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1050			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1051			\
1052			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1053			} \
1054			} \
1055			} \
1056			}
1057
1058		✗	HORZCLOSE_TRANSITION(8, uint8_t, 1)
1059		✗	HORZCLOSE_TRANSITION(16, uint16_t, 2)
1060
1061		✗	static float frand(int x, int y)
1062			{
1063		✗	const float r = sinf(x * 12.9898f + y * 78.233f) * 43758.545f;
1064
1065		✗	return r - floorf(r);
1066			}
1067
1068			#define DISSOLVE_TRANSITION(name, type, div) \
1069			static void dissolve##name##_transition(AVFilterContext *ctx, \
1070			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1071			float progress, \
1072			int slice_start, int slice_end, int jobnr) \
1073			{ \
1074			XFadeContext *s = ctx->priv; \
1075			const int nb_planes = s->nb_planes; \
1076			const int width = out->width; \
1077			\
1078			for (int y = slice_start; y < slice_end; y++) { \
1079			for (int x = 0; x < width; x++) { \
1080			const float smooth = frand(x, y) * 2.f + progress * 2.f - 1.5f; \
1081			for (int p = 0; p < nb_planes; p++) { \
1082			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1083			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1084			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1085			\
1086			dst[x] = smooth >= 0.5f ? xf0[x] : xf1[x]; \
1087			} \
1088			} \
1089			} \
1090			}
1091
1092		✗	DISSOLVE_TRANSITION(8, uint8_t, 1)
1093		✗	DISSOLVE_TRANSITION(16, uint16_t, 2)
1094
1095			#define PIXELIZE_TRANSITION(name, type, div) \
1096			static void pixelize##name##_transition(AVFilterContext *ctx, \
1097			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1098			float progress, \
1099			int slice_start, int slice_end, int jobnr) \
1100			{ \
1101			XFadeContext *s = ctx->priv; \
1102			const int nb_planes = s->nb_planes; \
1103			const int w = out->width; \
1104			const int h = out->height; \
1105			const float d = fminf(progress, 1.f - progress); \
1106			const float dist = ceilf(d * 50.f) / 50.f; \
1107			const float sqx = 2.f * dist * FFMIN(w, h) / 20.f; \
1108			const float sqy = 2.f * dist * FFMIN(w, h) / 20.f; \
1109			\
1110			for (int y = slice_start; y < slice_end; y++) { \
1111			for (int x = 0; x < w; x++) { \
1112			int sx = dist > 0.f ? FFMIN((floorf(x / sqx) + .5f) * sqx, w - 1) : x; \
1113			int sy = dist > 0.f ? FFMIN((floorf(y / sqy) + .5f) * sqy, h - 1) : y; \
1114			for (int p = 0; p < nb_planes; p++) { \
1115			const type *xf0 = (const type *)(a->data[p] + sy * a->linesize[p]); \
1116			const type *xf1 = (const type *)(b->data[p] + sy * b->linesize[p]); \
1117			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1118			\
1119			dst[x] = mix(xf0[sx], xf1[sx], progress); \
1120			} \
1121			} \
1122			} \
1123			}
1124
1125		✗	PIXELIZE_TRANSITION(8, uint8_t, 1)
1126		✗	PIXELIZE_TRANSITION(16, uint16_t, 2)
1127
1128			#define DIAGTL_TRANSITION(name, type, div) \
1129			static void diagtl##name##_transition(AVFilterContext *ctx, \
1130			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1131			float progress, \
1132			int slice_start, int slice_end, int jobnr) \
1133			{ \
1134			XFadeContext *s = ctx->priv; \
1135			const int nb_planes = s->nb_planes; \
1136			const int width = out->width; \
1137			const float w = width; \
1138			const float h = out->height; \
1139			\
1140			for (int y = slice_start; y < slice_end; y++) { \
1141			for (int x = 0; x < width; x++) { \
1142			const float smooth = 1.f + x / w * y / h - progress * 2.f; \
1143			\
1144			for (int p = 0; p < nb_planes; p++) { \
1145			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1146			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1147			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1148			\
1149			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1150			} \
1151			} \
1152			} \
1153			}
1154
1155		✗	DIAGTL_TRANSITION(8, uint8_t, 1)
1156		✗	DIAGTL_TRANSITION(16, uint16_t, 2)
1157
1158			#define DIAGTR_TRANSITION(name, type, div) \
1159			static void diagtr##name##_transition(AVFilterContext *ctx, \
1160			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1161			float progress, \
1162			int slice_start, int slice_end, int jobnr) \
1163			{ \
1164			XFadeContext *s = ctx->priv; \
1165			const int nb_planes = s->nb_planes; \
1166			const int width = out->width; \
1167			const float w = width; \
1168			const float h = out->height; \
1169			\
1170			for (int y = slice_start; y < slice_end; y++) { \
1171			for (int x = 0; x < width; x++) { \
1172			const float smooth = 1.f + (w - 1 - x) / w * y / h - progress * 2.f; \
1173			\
1174			for (int p = 0; p < nb_planes; p++) { \
1175			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1176			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1177			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1178			\
1179			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1180			} \
1181			} \
1182			} \
1183			}
1184
1185		✗	DIAGTR_TRANSITION(8, uint8_t, 1)
1186		✗	DIAGTR_TRANSITION(16, uint16_t, 2)
1187
1188			#define DIAGBL_TRANSITION(name, type, div) \
1189			static void diagbl##name##_transition(AVFilterContext *ctx, \
1190			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1191			float progress, \
1192			int slice_start, int slice_end, int jobnr) \
1193			{ \
1194			XFadeContext *s = ctx->priv; \
1195			const int nb_planes = s->nb_planes; \
1196			const int width = out->width; \
1197			const float w = width; \
1198			const float h = out->height; \
1199			\
1200			for (int y = slice_start; y < slice_end; y++) { \
1201			for (int x = 0; x < width; x++) { \
1202			const float smooth = 1.f + x / w * (h - 1 - y) / h - progress * 2.f; \
1203			\
1204			for (int p = 0; p < nb_planes; p++) { \
1205			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1206			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1207			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1208			\
1209			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1210			} \
1211			} \
1212			} \
1213			}
1214
1215		✗	DIAGBL_TRANSITION(8, uint8_t, 1)
1216		✗	DIAGBL_TRANSITION(16, uint16_t, 2)
1217
1218			#define DIAGBR_TRANSITION(name, type, div) \
1219			static void diagbr##name##_transition(AVFilterContext *ctx, \
1220			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1221			float progress, \
1222			int slice_start, int slice_end, int jobnr) \
1223			{ \
1224			XFadeContext *s = ctx->priv; \
1225			const int nb_planes = s->nb_planes; \
1226			const int width = out->width; \
1227			const float w = width; \
1228			const float h = out->height; \
1229			\
1230			for (int y = slice_start; y < slice_end; y++) { \
1231			for (int x = 0; x < width; x++) { \
1232			const float smooth = 1.f + (w - 1 - x) / w * (h - 1 - y) / h - \
1233			progress * 2.f; \
1234			\
1235			for (int p = 0; p < nb_planes; p++) { \
1236			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1237			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1238			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1239			\
1240			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
1241			} \
1242			} \
1243			} \
1244			}
1245
1246		✗	DIAGBR_TRANSITION(8, uint8_t, 1)
1247		✗	DIAGBR_TRANSITION(16, uint16_t, 2)
1248
1249			#define HLSLICE_TRANSITION(name, type, div) \
1250			static void hlslice##name##_transition(AVFilterContext *ctx, \
1251			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1252			float progress, \
1253			int slice_start, int slice_end, int jobnr) \
1254			{ \
1255			XFadeContext *s = ctx->priv; \
1256			const int nb_planes = s->nb_planes; \
1257			const int width = out->width; \
1258			const float w = width; \
1259			\
1260			for (int y = slice_start; y < slice_end; y++) { \
1261			for (int x = 0; x < width; x++) { \
1262			const float smooth = smoothstep(-0.5f, 0.f, x / w - progress * 1.5f); \
1263			const float ss = smooth <= fract(10.f * x / w) ? 0.f : 1.f; \
1264			\
1265			for (int p = 0; p < nb_planes; p++) { \
1266			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1267			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1268			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1269			\
1270			dst[x] = mix(xf1[x], xf0[x], ss); \
1271			} \
1272			} \
1273			} \
1274			}
1275
1276		✗	HLSLICE_TRANSITION(8, uint8_t, 1)
1277		✗	HLSLICE_TRANSITION(16, uint16_t, 2)
1278
1279			#define HRSLICE_TRANSITION(name, type, div) \
1280			static void hrslice##name##_transition(AVFilterContext *ctx, \
1281			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1282			float progress, \
1283			int slice_start, int slice_end, int jobnr) \
1284			{ \
1285			XFadeContext *s = ctx->priv; \
1286			const int nb_planes = s->nb_planes; \
1287			const int width = out->width; \
1288			const float w = width; \
1289			\
1290			for (int y = slice_start; y < slice_end; y++) { \
1291			for (int x = 0; x < width; x++) { \
1292			const float xx = (w - 1 - x) / w; \
1293			const float smooth = smoothstep(-0.5f, 0.f, xx - progress * 1.5f); \
1294			const float ss = smooth <= fract(10.f * xx) ? 0.f : 1.f; \
1295			\
1296			for (int p = 0; p < nb_planes; p++) { \
1297			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1298			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1299			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1300			\
1301			dst[x] = mix(xf1[x], xf0[x], ss); \
1302			} \
1303			} \
1304			} \
1305			}
1306
1307		✗	HRSLICE_TRANSITION(8, uint8_t, 1)
1308		✗	HRSLICE_TRANSITION(16, uint16_t, 2)
1309
1310			#define VUSLICE_TRANSITION(name, type, div) \
1311			static void vuslice##name##_transition(AVFilterContext *ctx, \
1312			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1313			float progress, \
1314			int slice_start, int slice_end, int jobnr) \
1315			{ \
1316			XFadeContext *s = ctx->priv; \
1317			const int nb_planes = s->nb_planes; \
1318			const int width = out->width; \
1319			const float h = out->height; \
1320			\
1321			for (int y = slice_start; y < slice_end; y++) { \
1322			const float smooth = smoothstep(-0.5f, 0.f, y / h - progress * 1.5f); \
1323			const float ss = smooth <= fract(10.f * y / h) ? 0.f : 1.f; \
1324			\
1325			for (int x = 0; x < width; x++) { \
1326			for (int p = 0; p < nb_planes; p++) { \
1327			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1328			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1329			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1330			\
1331			dst[x] = mix(xf1[x], xf0[x], ss); \
1332			} \
1333			} \
1334			} \
1335			}
1336
1337		✗	VUSLICE_TRANSITION(8, uint8_t, 1)
1338		✗	VUSLICE_TRANSITION(16, uint16_t, 2)
1339
1340			#define VDSLICE_TRANSITION(name, type, div) \
1341			static void vdslice##name##_transition(AVFilterContext *ctx, \
1342			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1343			float progress, \
1344			int slice_start, int slice_end, int jobnr) \
1345			{ \
1346			XFadeContext *s = ctx->priv; \
1347			const int nb_planes = s->nb_planes; \
1348			const int width = out->width; \
1349			const float h = out->height; \
1350			\
1351			for (int y = slice_start; y < slice_end; y++) { \
1352			const float yy = (h - 1 - y) / h; \
1353			const float smooth = smoothstep(-0.5f, 0.f, yy - progress * 1.5f); \
1354			const float ss = smooth <= fract(10.f * yy) ? 0.f : 1.f; \
1355			\
1356			for (int x = 0; x < width; x++) { \
1357			for (int p = 0; p < nb_planes; p++) { \
1358			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1359			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1360			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1361			\
1362			dst[x] = mix(xf1[x], xf0[x], ss); \
1363			} \
1364			} \
1365			} \
1366			}
1367
1368		✗	VDSLICE_TRANSITION(8, uint8_t, 1)
1369		✗	VDSLICE_TRANSITION(16, uint16_t, 2)
1370
1371			#define HBLUR_TRANSITION(name, type, div) \
1372			static void hblur##name##_transition(AVFilterContext *ctx, \
1373			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1374			float progress, \
1375			int slice_start, int slice_end, int jobnr) \
1376			{ \
1377			XFadeContext *s = ctx->priv; \
1378			const int nb_planes = s->nb_planes; \
1379			const int width = out->width; \
1380			const float prog = progress <= 0.5f ? progress * 2.f : (1.f - progress) * 2.f; \
1381			const int size = 1 + (width / 2) * prog; \
1382			\
1383			for (int y = slice_start; y < slice_end; y++) { \
1384			for (int p = 0; p < nb_planes; p++) { \
1385			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1386			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1387			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1388			float sum0 = 0.f; \
1389			float sum1 = 0.f; \
1390			float cnt = size; \
1391			\
1392			for (int x = 0; x < size; x++) { \
1393			sum0 += xf0[x]; \
1394			sum1 += xf1[x]; \
1395			} \
1396			\
1397			for (int x = 0; x < width; x++) { \
1398			dst[x] = mix(sum0 / cnt, sum1 / cnt, progress); \
1399			\
1400			if (x + size < width) { \
1401			sum0 += xf0[x + size] - xf0[x]; \
1402			sum1 += xf1[x + size] - xf1[x]; \
1403			} else { \
1404			sum0 -= xf0[x]; \
1405			sum1 -= xf1[x]; \
1406			cnt--; \
1407			} \
1408			} \
1409			} \
1410			} \
1411			}
1412
1413		✗	HBLUR_TRANSITION(8, uint8_t, 1)
1414		✗	HBLUR_TRANSITION(16, uint16_t, 2)
1415
1416			#define FADEGRAYS_TRANSITION(name, type, div) \
1417			static void fadegrays##name##_transition(AVFilterContext *ctx, \
1418			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1419			float progress, \
1420			int slice_start, int slice_end, int jobnr) \
1421			{ \
1422			XFadeContext *s = ctx->priv; \
1423			const int width = out->width; \
1424			const int is_rgb = s->is_rgb; \
1425			const int mid = (s->max_value + 1) / 2; \
1426			const float phase = 0.2f; \
1427			\
1428			for (int y = slice_start; y < slice_end; y++) { \
1429			for (int x = 0; x < width; x++) { \
1430			int bg[2][4]; \
1431			if (is_rgb) { \
1432			bg[0][0] = bg[1][0] = 0; \
1433			for (int p = 0; p < s->nb_planes; p++) { \
1434			const type *xf0 = (const type *)(a->data[p] + \
1435			y * a->linesize[p]); \
1436			const type *xf1 = (const type *)(b->data[p] + \
1437			y * b->linesize[p]); \
1438			if (p == 3) { \
1439			bg[0][3] = xf0[x]; \
1440			bg[1][3] = xf1[x]; \
1441			} else { \
1442			bg[0][0] += xf0[x]; \
1443			bg[1][0] += xf1[x]; \
1444			} \
1445			} \
1446			bg[0][0] = bg[0][0] / 3; \
1447			bg[1][0] = bg[1][0] / 3; \
1448			bg[0][1] = bg[0][2] = bg[0][0]; \
1449			bg[1][1] = bg[1][2] = bg[1][0]; \
1450			} else { \
1451			const type *yf0 = (const type *)(a->data[0] + \
1452			y * a->linesize[0]); \
1453			const type *yf1 = (const type *)(b->data[0] + \
1454			y * a->linesize[0]); \
1455			bg[0][0] = yf0[x]; \
1456			bg[1][0] = yf1[x]; \
1457			if (s->nb_planes == 4) { \
1458			const type *af0 = (const type *)(a->data[3] + \
1459			y * a->linesize[3]); \
1460			const type *af1 = (const type *)(b->data[3] + \
1461			y * a->linesize[3]); \
1462			bg[0][3] = af0[x]; \
1463			bg[1][3] = af1[x]; \
1464			} \
1465			bg[0][1] = bg[1][1] = mid; \
1466			bg[0][2] = bg[1][2] = mid; \
1467			} \
1468			\
1469			for (int p = 0; p < s->nb_planes; p++) { \
1470			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1471			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1472			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1473			\
1474			dst[x] = mix(mix(xf0[x], bg[0][p], \
1475			smoothstep(1.f-phase, 1.f, progress)), \
1476			mix(bg[1][p], xf1[x], smoothstep(phase, 1.f, progress)), \
1477			progress); \
1478			} \
1479			} \
1480			} \
1481			}
1482
1483		✗	FADEGRAYS_TRANSITION(8, uint8_t, 1)
1484		✗	FADEGRAYS_TRANSITION(16, uint16_t, 2)
1485
1486			#define WIPETL_TRANSITION(name, type, div) \
1487			static void wipetl##name##_transition(AVFilterContext *ctx, \
1488			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1489			float progress, \
1490			int slice_start, int slice_end, int jobnr) \
1491			{ \
1492			XFadeContext *s = ctx->priv; \
1493			const int height = slice_end - slice_start; \
1494			const int width = out->width; \
1495			const int zw = out->width * progress; \
1496			const int zh = out->height * progress; \
1497			\
1498			for (int p = 0; p < s->nb_planes; p++) { \
1499			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1500			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1501			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1502			\
1503			for (int y = 0; y < height; y++) { \
1504			for (int x = 0; x < width; x++) { \
1505			dst[x] = slice_start + y <= zh && \
1506			x <= zw ? xf0[x] : xf1[x]; \
1507			} \
1508			\
1509			dst += out->linesize[p] / div; \
1510			xf0 += a->linesize[p] / div; \
1511			xf1 += b->linesize[p] / div; \
1512			} \
1513			} \
1514			}
1515
1516		✗	WIPETL_TRANSITION(8, uint8_t, 1)
1517		✗	WIPETL_TRANSITION(16, uint16_t, 2)
1518
1519			#define WIPETR_TRANSITION(name, type, div) \
1520			static void wipetr##name##_transition(AVFilterContext *ctx, \
1521			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1522			float progress, \
1523			int slice_start, int slice_end, int jobnr) \
1524			{ \
1525			XFadeContext *s = ctx->priv; \
1526			const int height = slice_end - slice_start; \
1527			const int width = out->width; \
1528			const int zw = width * (1.f - progress); \
1529			const int zh = out->height * progress; \
1530			\
1531			for (int p = 0; p < s->nb_planes; p++) { \
1532			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1533			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1534			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1535			\
1536			for (int y = 0; y < height; y++) { \
1537			for (int x = 0; x < width; x++) { \
1538			dst[x] = slice_start + y <= zh && \
1539			x > zw ? xf0[x] : xf1[x]; \
1540			} \
1541			\
1542			dst += out->linesize[p] / div; \
1543			xf0 += a->linesize[p] / div; \
1544			xf1 += b->linesize[p] / div; \
1545			} \
1546			} \
1547			}
1548
1549		✗	WIPETR_TRANSITION(8, uint8_t, 1)
1550		✗	WIPETR_TRANSITION(16, uint16_t, 2)
1551
1552			#define WIPEBL_TRANSITION(name, type, div) \
1553			static void wipebl##name##_transition(AVFilterContext *ctx, \
1554			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1555			float progress, \
1556			int slice_start, int slice_end, int jobnr) \
1557			{ \
1558			XFadeContext *s = ctx->priv; \
1559			const int height = slice_end - slice_start; \
1560			const int width = out->width; \
1561			const int zw = width * progress; \
1562			const int zh = out->height * (1.f - progress); \
1563			\
1564			for (int p = 0; p < s->nb_planes; p++) { \
1565			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1566			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1567			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1568			\
1569			for (int y = 0; y < height; y++) { \
1570			for (int x = 0; x < width; x++) { \
1571			dst[x] = slice_start + y > zh && \
1572			x <= zw ? xf0[x] : xf1[x]; \
1573			} \
1574			\
1575			dst += out->linesize[p] / div; \
1576			xf0 += a->linesize[p] / div; \
1577			xf1 += b->linesize[p] / div; \
1578			} \
1579			} \
1580			}
1581
1582		✗	WIPEBL_TRANSITION(8, uint8_t, 1)
1583		✗	WIPEBL_TRANSITION(16, uint16_t, 2)
1584
1585			#define WIPEBR_TRANSITION(name, type, div) \
1586			static void wipebr##name##_transition(AVFilterContext *ctx, \
1587			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1588			float progress, \
1589			int slice_start, int slice_end, int jobnr) \
1590			{ \
1591			XFadeContext *s = ctx->priv; \
1592			const int height = slice_end - slice_start; \
1593			const int zh = out->height * (1.f - progress); \
1594			const int width = out->width; \
1595			const int zw = width * (1.f - progress); \
1596			\
1597			for (int p = 0; p < s->nb_planes; p++) { \
1598			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1599			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1600			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1601			\
1602			for (int y = 0; y < height; y++) { \
1603			for (int x = 0; x < width; x++) { \
1604			dst[x] = slice_start + y > zh && \
1605			x > zw ? xf0[x] : xf1[x]; \
1606			} \
1607			\
1608			dst += out->linesize[p] / div; \
1609			xf0 += a->linesize[p] / div; \
1610			xf1 += b->linesize[p] / div; \
1611			} \
1612			} \
1613			}
1614
1615		✗	WIPEBR_TRANSITION(8, uint8_t, 1)
1616		✗	WIPEBR_TRANSITION(16, uint16_t, 2)
1617
1618			#define SQUEEZEH_TRANSITION(name, type, div) \
1619			static void squeezeh##name##_transition(AVFilterContext *ctx, \
1620			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1621			float progress, \
1622			int slice_start, int slice_end, int jobnr) \
1623			{ \
1624			XFadeContext *s = ctx->priv; \
1625			const float h = out->height; \
1626			const int height = slice_end - slice_start; \
1627			const int width = out->width; \
1628			\
1629			for (int p = 0; p < s->nb_planes; p++) { \
1630			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1631			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1632			\
1633			for (int y = 0; y < height; y++) { \
1634			const float z = .5f + ((slice_start + y) / h - .5f) / progress; \
1635			\
1636			if (z < 0.f || z > 1.f) { \
1637			for (int x = 0; x < width; x++) \
1638			dst[x] = xf1[x]; \
1639			} else { \
1640			const int yy = lrintf(z * (h - 1.f)); \
1641			const type *xf0 = (const type *)(a->data[p] + yy * a->linesize[p]); \
1642			\
1643			for (int x = 0; x < width; x++) \
1644			dst[x] = xf0[x]; \
1645			} \
1646			\
1647			dst += out->linesize[p] / div; \
1648			xf1 += b->linesize[p] / div; \
1649			} \
1650			} \
1651			}
1652
1653		✗	SQUEEZEH_TRANSITION(8, uint8_t, 1)
1654		✗	SQUEEZEH_TRANSITION(16, uint16_t, 2)
1655
1656			#define SQUEEZEV_TRANSITION(name, type, div) \
1657			static void squeezev##name##_transition(AVFilterContext *ctx, \
1658			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1659			float progress, \
1660			int slice_start, int slice_end, int jobnr) \
1661			{ \
1662			XFadeContext *s = ctx->priv; \
1663			const int width = out->width; \
1664			const float w = width; \
1665			const int height = slice_end - slice_start; \
1666			\
1667			for (int p = 0; p < s->nb_planes; p++) { \
1668			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1669			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1670			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1671			\
1672			for (int y = 0; y < height; y++) { \
1673			for (int x = 0; x < width; x++) { \
1674			const float z = .5f + (x / w - .5f) / progress; \
1675			\
1676			if (z < 0.f || z > 1.f) { \
1677			dst[x] = xf1[x]; \
1678			} else { \
1679			const int xx = lrintf(z * (w - 1.f)); \
1680			\
1681			dst[x] = xf0[xx]; \
1682			} \
1683			} \
1684			\
1685			dst += out->linesize[p] / div; \
1686			xf0 += a->linesize[p] / div; \
1687			xf1 += b->linesize[p] / div; \
1688			} \
1689			} \
1690			}
1691
1692		✗	SQUEEZEV_TRANSITION(8, uint8_t, 1)
1693		✗	SQUEEZEV_TRANSITION(16, uint16_t, 2)
1694
1695		✗	static void zoom(float *u, float *v, float amount)
1696			{
1697		✗	*u = 0.5f + ((*u - 0.5f) * amount);
1698		✗	*v = 0.5f + ((*v - 0.5f) * amount);
1699		✗	}
1700
1701			#define ZOOMIN_TRANSITION(name, type, div) \
1702			static void zoomin##name##_transition(AVFilterContext *ctx, \
1703			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1704			float progress, \
1705			int slice_start, int slice_end, int jobnr) \
1706			{ \
1707			XFadeContext *s = ctx->priv; \
1708			const int width = out->width; \
1709			const float w = width; \
1710			const float h = out->height; \
1711			const float zf = smoothstep(0.5f, 1.f, progress); \
1712			\
1713			for (int p = 0; p < s->nb_planes; p++) { \
1714			const type *xf0 = (const type *)(a->data[p]); \
1715			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1716			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1717			\
1718			for (int y = slice_start; y < slice_end; y++) { \
1719			for (int x = 0; x < width; x++) { \
1720			float zv, u, v; \
1721			int iu, iv; \
1722			\
1723			u = x / w; \
1724			v = y / h; \
1725			zoom(&u, &v, zf); \
1726			iu = ceilf(u * (w - 1)); \
1727			iv = ceilf(v * (h - 1)); \
1728			zv = xf0[iu + iv * a->linesize[p] / div]; \
1729			dst[x] = mix(zv, xf1[x], smoothstep(0.f, 0.5f, progress)); \
1730			} \
1731			dst += out->linesize[p] / div; \
1732			xf1 += b->linesize[p] / div; \
1733			} \
1734			} \
1735			}
1736
1737		✗	ZOOMIN_TRANSITION(8, uint8_t, 1)
1738		✗	ZOOMIN_TRANSITION(16, uint16_t, 2)
1739
1740			#define FADEFAST_TRANSITION(name, type, div) \
1741			static void fadefast##name##_transition(AVFilterContext *ctx, \
1742			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1743			float progress, \
1744			int slice_start, int slice_end, int jobnr) \
1745			{ \
1746			XFadeContext *s = ctx->priv; \
1747			const int height = slice_end - slice_start; \
1748			const int width = out->width; \
1749			const float imax = 1.f / s->max_value; \
1750			\
1751			for (int p = 0; p < s->nb_planes; p++) { \
1752			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1753			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1754			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1755			\
1756			for (int y = 0; y < height; y++) { \
1757			for (int x = 0; x < width; x++) { \
1758			dst[x] = mix(xf0[x], xf1[x], powf(progress, 1.f + \
1759			logf(1.f+FFABS(xf0[x]-xf1[x])*imax)\
1760			)); \
1761			} \
1762			\
1763			dst += out->linesize[p] / div; \
1764			xf0 += a->linesize[p] / div; \
1765			xf1 += b->linesize[p] / div; \
1766			} \
1767			} \
1768			}
1769
1770		✗	FADEFAST_TRANSITION(8, uint8_t, 1)
1771		✗	FADEFAST_TRANSITION(16, uint16_t, 2)
1772
1773			#define FADESLOW_TRANSITION(name, type, div) \
1774			static void fadeslow##name##_transition(AVFilterContext *ctx, \
1775			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1776			float progress, \
1777			int slice_start, int slice_end, int jobnr) \
1778			{ \
1779			XFadeContext *s = ctx->priv; \
1780			const int height = slice_end - slice_start; \
1781			const int width = out->width; \
1782			const float imax = 1.f / s->max_value; \
1783			\
1784			for (int p = 0; p < s->nb_planes; p++) { \
1785			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1786			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1787			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1788			\
1789			for (int y = 0; y < height; y++) { \
1790			for (int x = 0; x < width; x++) { \
1791			dst[x] = mix(xf0[x], xf1[x], powf(progress, 1.f + \
1792			logf(2.f-FFABS(xf0[x]-xf1[x])*imax)\
1793			)); \
1794			} \
1795			\
1796			dst += out->linesize[p] / div; \
1797			xf0 += a->linesize[p] / div; \
1798			xf1 += b->linesize[p] / div; \
1799			} \
1800			} \
1801			}
1802
1803		✗	FADESLOW_TRANSITION(8, uint8_t, 1)
1804		✗	FADESLOW_TRANSITION(16, uint16_t, 2)
1805
1806			#define HWIND_TRANSITION(name, z, type, div, expr) \
1807			static void h##z##wind##name##_transition(AVFilterContext *ctx, \
1808			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1809			float progress, \
1810			int slice_start, int slice_end, int jobnr) \
1811			{ \
1812			XFadeContext *s = ctx->priv; \
1813			const int width = out->width; \
1814			\
1815			for (int y = slice_start; y < slice_end; y++) { \
1816			const float r = frand(0, y); \
1817			for (int x = 0; x < width; x++) { \
1818			const float fx = expr x / (float)width; \
1819			for (int p = 0; p < s->nb_planes; p++) { \
1820			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1821			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1822			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1823			\
1824			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f,-0.2f, fx * (1.f - 0.2f)\
1825			+ 0.2f * r - (1.f - progress)\
1826			* (1.f + 0.2f))); \
1827			} \
1828			} \
1829			} \
1830			}
1831
1832		✗	HWIND_TRANSITION(8, l, uint8_t, 1, 1.f - )
1833		✗	HWIND_TRANSITION(16, l, uint16_t, 2, 1.f - )
1834		✗	HWIND_TRANSITION(8, r, uint8_t, 1, )
1835		✗	HWIND_TRANSITION(16, r, uint16_t, 2, )
1836
1837			#define VWIND_TRANSITION(name, z, type, div, expr) \
1838			static void v##z##wind##name##_transition(AVFilterContext *ctx, \
1839			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1840			float progress, \
1841			int slice_start, int slice_end, int jobnr) \
1842			{ \
1843			XFadeContext *s = ctx->priv; \
1844			const int width = out->width; \
1845			\
1846			for (int y = slice_start; y < slice_end; y++) { \
1847			const float fy = expr y / (float)out->height; \
1848			for (int x = 0; x < width; x++) { \
1849			const float r = frand(x, 0); \
1850			for (int p = 0; p < s->nb_planes; p++) { \
1851			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1852			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1853			type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
1854			\
1855			dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f,-0.2f, fy * (1.f - 0.2f) \
1856			+ 0.2f * r - (1.f - progress)\
1857			* (1.f + 0.2f))); \
1858			} \
1859			} \
1860			} \
1861			}
1862
1863		✗	VWIND_TRANSITION(8, u, uint8_t, 1, 1.f - )
1864		✗	VWIND_TRANSITION(16, u, uint16_t, 2, 1.f - )
1865		✗	VWIND_TRANSITION(8, d, uint8_t, 1, )
1866		✗	VWIND_TRANSITION(16, d, uint16_t, 2, )
1867
1868			#define COVERH_TRANSITION(dir, name, type, div, expr) \
1869			static void cover##dir##name##_transition(AVFilterContext *ctx, \
1870			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1871			float progress, \
1872			int slice_start, int slice_end, int jobnr) \
1873			{ \
1874			XFadeContext *s = ctx->priv; \
1875			const int height = slice_end - slice_start; \
1876			const int width = out->width; \
1877			const int z = (expr progress) * width; \
1878			\
1879			for (int p = 0; p < s->nb_planes; p++) { \
1880			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1881			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1882			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1883			\
1884			for (int y = 0; y < height; y++) { \
1885			for (int x = 0; x < width; x++) { \
1886			const int zx = z + x; \
1887			const int zz = zx % width + width * (zx < 0); \
1888			dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[x]; \
1889			} \
1890			\
1891			dst += out->linesize[p] / div; \
1892			xf0 += a->linesize[p] / div; \
1893			xf1 += b->linesize[p] / div; \
1894			} \
1895			} \
1896			}
1897
1898		✗	COVERH_TRANSITION(left, 8, uint8_t, 1, -)
1899		✗	COVERH_TRANSITION(left, 16, uint16_t, 2, -)
1900		✗	COVERH_TRANSITION(right, 8, uint8_t, 1, )
1901		✗	COVERH_TRANSITION(right, 16, uint16_t, 2, )
1902
1903			#define COVERV_TRANSITION(dir, name, type, div, expr) \
1904			static void cover##dir##name##_transition(AVFilterContext *ctx, \
1905			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1906			float progress, \
1907			int slice_start, int slice_end, int jobnr) \
1908			{ \
1909			XFadeContext *s = ctx->priv; \
1910			const int height = out->height; \
1911			const int width = out->width; \
1912			const int z = (expr progress) * height; \
1913			\
1914			for (int p = 0; p < s->nb_planes; p++) { \
1915			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1916			\
1917			for (int y = slice_start; y < slice_end; y++) { \
1918			const int zy = z + y; \
1919			const int zz = zy % height + height * (zy < 0); \
1920			const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
1921			const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
1922			\
1923			for (int x = 0; x < width; x++) \
1924			dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
1925			\
1926			dst += out->linesize[p] / div; \
1927			} \
1928			} \
1929			}
1930
1931		✗	COVERV_TRANSITION(up, 8, uint8_t, 1, -)
1932		✗	COVERV_TRANSITION(up, 16, uint16_t, 2, -)
1933		✗	COVERV_TRANSITION(down, 8, uint8_t, 1, )
1934		✗	COVERV_TRANSITION(down, 16, uint16_t, 2, )
1935
1936			#define REVEALH_TRANSITION(dir, name, type, div, expr) \
1937			static void reveal##dir##name##_transition(AVFilterContext *ctx, \
1938			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1939			float progress, \
1940			int slice_start, int slice_end, int jobnr) \
1941			{ \
1942			XFadeContext *s = ctx->priv; \
1943			const int height = slice_end - slice_start; \
1944			const int width = out->width; \
1945			const int z = (expr progress) * width; \
1946			\
1947			for (int p = 0; p < s->nb_planes; p++) { \
1948			const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
1949			const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
1950			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1951			\
1952			for (int y = 0; y < height; y++) { \
1953			for (int x = 0; x < width; x++) { \
1954			const int zx = z + x; \
1955			const int zz = zx % width + width * (zx < 0); \
1956			dst[x] = (zx >= 0) && (zx < width) ? xf1[x] : xf0[zz]; \
1957			} \
1958			\
1959			dst += out->linesize[p] / div; \
1960			xf0 += a->linesize[p] / div; \
1961			xf1 += b->linesize[p] / div; \
1962			} \
1963			} \
1964			}
1965
1966		✗	REVEALH_TRANSITION(left, 8, uint8_t, 1, -)
1967		✗	REVEALH_TRANSITION(left, 16, uint16_t, 2, -)
1968		✗	REVEALH_TRANSITION(right, 8, uint8_t, 1, )
1969		✗	REVEALH_TRANSITION(right, 16, uint16_t, 2, )
1970
1971			#define REVEALV_TRANSITION(dir, name, type, div, expr) \
1972			static void reveal##dir##name##_transition(AVFilterContext *ctx, \
1973			const AVFrame *a, const AVFrame *b, AVFrame *out, \
1974			float progress, \
1975			int slice_start, int slice_end, int jobnr) \
1976			{ \
1977			XFadeContext *s = ctx->priv; \
1978			const int height = out->height; \
1979			const int width = out->width; \
1980			const int z = (expr progress) * height; \
1981			\
1982			for (int p = 0; p < s->nb_planes; p++) { \
1983			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
1984			\
1985			for (int y = slice_start; y < slice_end; y++) { \
1986			const int zy = z + y; \
1987			const int zz = zy % height + height * (zy < 0); \
1988			const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
1989			const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
1990			\
1991			for (int x = 0; x < width; x++) \
1992			dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
1993			\
1994			dst += out->linesize[p] / div; \
1995			} \
1996			} \
1997			}
1998
1999		✗	REVEALV_TRANSITION(up, 8, uint8_t, 1, -)
2000		✗	REVEALV_TRANSITION(up, 16, uint16_t, 2, -)
2001		✗	REVEALV_TRANSITION(down, 8, uint8_t, 1, )
2002		✗	REVEALV_TRANSITION(down, 16, uint16_t, 2, )
2003
2004		✗	static inline double getpix(void *priv, double x, double y, int plane, int nb)
2005			{
2006		✗	XFadeContext *s = priv;
2007		✗	AVFrame *in = s->xf[nb];
2008		✗	const uint8_t *src = in->data[FFMIN(plane, s->nb_planes - 1)];
2009		✗	int linesize = in->linesize[FFMIN(plane, s->nb_planes - 1)];
2010		✗	const int w = in->width;
2011		✗	const int h = in->height;
2012
2013			int xi, yi;
2014
2015		✗	xi = av_clipd(x, 0, w - 1);
2016		✗	yi = av_clipd(y, 0, h - 1);
2017
2018		✗	if (s->depth > 8) {
2019		✗	const uint16_t *src16 = (const uint16_t*)src;
2020
2021		✗	linesize /= 2;
2022		✗	return src16[xi + yi * linesize];
2023			} else {
2024		✗	return src[xi + yi * linesize];
2025			}
2026			}
2027
2028		✗	static double a0(void *priv, double x, double y) { return getpix(priv, x, y, 0, 0); }
2029		✗	static double a1(void *priv, double x, double y) { return getpix(priv, x, y, 1, 0); }
2030		✗	static double a2(void *priv, double x, double y) { return getpix(priv, x, y, 2, 0); }
2031		✗	static double a3(void *priv, double x, double y) { return getpix(priv, x, y, 3, 0); }
2032
2033		✗	static double b0(void *priv, double x, double y) { return getpix(priv, x, y, 0, 1); }
2034		✗	static double b1(void *priv, double x, double y) { return getpix(priv, x, y, 1, 1); }
2035		✗	static double b2(void *priv, double x, double y) { return getpix(priv, x, y, 2, 1); }
2036		✗	static double b3(void *priv, double x, double y) { return getpix(priv, x, y, 3, 1); }
2037
2038		✗	static int config_output(AVFilterLink *outlink)
2039			{
2040		✗	AVFilterContext *ctx = outlink->src;
2041		✗	AVFilterLink *inlink0 = ctx->inputs[0];
2042		✗	AVFilterLink *inlink1 = ctx->inputs[1];
2043		✗	FilterLink *inl0 = ff_filter_link(inlink0);
2044		✗	FilterLink *inl1 = ff_filter_link(inlink1);
2045		✗	FilterLink *ol = ff_filter_link(outlink);
2046		✗	XFadeContext *s = ctx->priv;
2047		✗	const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink0->format);
2048
2049		✗	if (inlink0->w != inlink1->w || inlink0->h != inlink1->h) {
2050		✗	av_log(ctx, AV_LOG_ERROR, "First input link %s parameters "
2051			"(size %dx%d) do not match the corresponding "
2052			"second input link %s parameters (size %dx%d)\n",
2053		✗	ctx->input_pads[0].name, inlink0->w, inlink0->h,
2054		✗	ctx->input_pads[1].name, inlink1->w, inlink1->h);
2055		✗	return AVERROR(EINVAL);
2056			}
2057
2058		✗	if (inlink0->time_base.num != inlink1->time_base.num ||
2059		✗	inlink0->time_base.den != inlink1->time_base.den) {
2060		✗	av_log(ctx, AV_LOG_ERROR, "First input link %s timebase "
2061			"(%d/%d) do not match the corresponding "
2062			"second input link %s timebase (%d/%d)\n",
2063		✗	ctx->input_pads[0].name, inlink0->time_base.num, inlink0->time_base.den,
2064		✗	ctx->input_pads[1].name, inlink1->time_base.num, inlink1->time_base.den);
2065		✗	return AVERROR(EINVAL);
2066			}
2067
2068		✗	if (!inl0->frame_rate.num || !inl0->frame_rate.den) {
2069		✗	av_log(ctx, AV_LOG_ERROR, "The inputs needs to be a constant frame rate; "
2070			"current rate of %d/%d is invalid\n", inl0->frame_rate.num, inl0->frame_rate.den);
2071		✗	return AVERROR(EINVAL);
2072			}
2073
2074		✗	if (inl0->frame_rate.num != inl1->frame_rate.num ||
2075		✗	inl0->frame_rate.den != inl1->frame_rate.den) {
2076		✗	av_log(ctx, AV_LOG_ERROR, "First input link %s frame rate "
2077			"(%d/%d) do not match the corresponding "
2078			"second input link %s frame rate (%d/%d)\n",
2079		✗	ctx->input_pads[0].name, inl0->frame_rate.num, inl0->frame_rate.den,
2080		✗	ctx->input_pads[1].name, inl1->frame_rate.num, inl1->frame_rate.den);
2081		✗	return AVERROR(EINVAL);
2082			}
2083
2084		✗	outlink->w = inlink0->w;
2085		✗	outlink->h = inlink0->h;
2086		✗	outlink->time_base = inlink0->time_base;
2087		✗	outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
2088		✗	ol->frame_rate = inl0->frame_rate;
2089
2090		✗	s->depth = pix_desc->comp[0].depth;
2091		✗	s->is_rgb = !!(pix_desc->flags & AV_PIX_FMT_FLAG_RGB);
2092		✗	s->nb_planes = av_pix_fmt_count_planes(inlink0->format);
2093		✗	s->max_value = (1 << s->depth) - 1;
2094		✗	s->black[0] = 0;
2095		✗	s->black[1] = s->black[2] = s->is_rgb ? 0 : s->max_value / 2;
2096		✗	s->black[3] = s->max_value;
2097		✗	s->white[0] = s->white[3] = s->max_value;
2098		✗	s->white[1] = s->white[2] = s->is_rgb ? s->max_value : s->max_value / 2;
2099
2100		✗	s->start_pts = s->inputs_offset_pts = AV_NOPTS_VALUE;
2101
2102		✗	if (s->duration)
2103		✗	s->duration_pts = av_rescale_q(s->duration, AV_TIME_BASE_Q, outlink->time_base);
2104
2105		✗	switch (s->transition) {
2106		✗	case CUSTOM: s->transitionf = s->depth <= 8 ? custom8_transition : custom16_transition; break;
2107		✗	case FADE: s->transitionf = s->depth <= 8 ? fade8_transition : fade16_transition; break;
2108		✗	case WIPELEFT: s->transitionf = s->depth <= 8 ? wipeleft8_transition : wipeleft16_transition; break;
2109		✗	case WIPERIGHT: s->transitionf = s->depth <= 8 ? wiperight8_transition : wiperight16_transition; break;
2110		✗	case WIPEUP: s->transitionf = s->depth <= 8 ? wipeup8_transition : wipeup16_transition; break;
2111		✗	case WIPEDOWN: s->transitionf = s->depth <= 8 ? wipedown8_transition : wipedown16_transition; break;
2112		✗	case SLIDELEFT: s->transitionf = s->depth <= 8 ? slideleft8_transition : slideleft16_transition; break;
2113		✗	case SLIDERIGHT: s->transitionf = s->depth <= 8 ? slideright8_transition : slideright16_transition; break;
2114		✗	case SLIDEUP: s->transitionf = s->depth <= 8 ? slideup8_transition : slideup16_transition; break;
2115		✗	case SLIDEDOWN: s->transitionf = s->depth <= 8 ? slidedown8_transition : slidedown16_transition; break;
2116		✗	case CIRCLECROP: s->transitionf = s->depth <= 8 ? circlecrop8_transition : circlecrop16_transition; break;
2117		✗	case RECTCROP: s->transitionf = s->depth <= 8 ? rectcrop8_transition : rectcrop16_transition; break;
2118		✗	case DISTANCE: s->transitionf = s->depth <= 8 ? distance8_transition : distance16_transition; break;
2119		✗	case FADEBLACK: s->transitionf = s->depth <= 8 ? fadeblack8_transition : fadeblack16_transition; break;
2120		✗	case FADEWHITE: s->transitionf = s->depth <= 8 ? fadewhite8_transition : fadewhite16_transition; break;
2121		✗	case RADIAL: s->transitionf = s->depth <= 8 ? radial8_transition : radial16_transition; break;
2122		✗	case SMOOTHLEFT: s->transitionf = s->depth <= 8 ? smoothleft8_transition : smoothleft16_transition; break;
2123		✗	case SMOOTHRIGHT:s->transitionf = s->depth <= 8 ? smoothright8_transition: smoothright16_transition;break;
2124		✗	case SMOOTHUP: s->transitionf = s->depth <= 8 ? smoothup8_transition : smoothup16_transition; break;
2125		✗	case SMOOTHDOWN: s->transitionf = s->depth <= 8 ? smoothdown8_transition : smoothdown16_transition; break;
2126		✗	case CIRCLEOPEN: s->transitionf = s->depth <= 8 ? circleopen8_transition : circleopen16_transition; break;
2127		✗	case CIRCLECLOSE:s->transitionf = s->depth <= 8 ? circleclose8_transition: circleclose16_transition;break;
2128		✗	case VERTOPEN: s->transitionf = s->depth <= 8 ? vertopen8_transition : vertopen16_transition; break;
2129		✗	case VERTCLOSE: s->transitionf = s->depth <= 8 ? vertclose8_transition : vertclose16_transition; break;
2130		✗	case HORZOPEN: s->transitionf = s->depth <= 8 ? horzopen8_transition : horzopen16_transition; break;
2131		✗	case HORZCLOSE: s->transitionf = s->depth <= 8 ? horzclose8_transition : horzclose16_transition; break;
2132		✗	case DISSOLVE: s->transitionf = s->depth <= 8 ? dissolve8_transition : dissolve16_transition; break;
2133		✗	case PIXELIZE: s->transitionf = s->depth <= 8 ? pixelize8_transition : pixelize16_transition; break;
2134		✗	case DIAGTL: s->transitionf = s->depth <= 8 ? diagtl8_transition : diagtl16_transition; break;
2135		✗	case DIAGTR: s->transitionf = s->depth <= 8 ? diagtr8_transition : diagtr16_transition; break;
2136		✗	case DIAGBL: s->transitionf = s->depth <= 8 ? diagbl8_transition : diagbl16_transition; break;
2137		✗	case DIAGBR: s->transitionf = s->depth <= 8 ? diagbr8_transition : diagbr16_transition; break;
2138		✗	case HLSLICE: s->transitionf = s->depth <= 8 ? hlslice8_transition : hlslice16_transition; break;
2139		✗	case HRSLICE: s->transitionf = s->depth <= 8 ? hrslice8_transition : hrslice16_transition; break;
2140		✗	case VUSLICE: s->transitionf = s->depth <= 8 ? vuslice8_transition : vuslice16_transition; break;
2141		✗	case VDSLICE: s->transitionf = s->depth <= 8 ? vdslice8_transition : vdslice16_transition; break;
2142		✗	case HBLUR: s->transitionf = s->depth <= 8 ? hblur8_transition : hblur16_transition; break;
2143		✗	case FADEGRAYS: s->transitionf = s->depth <= 8 ? fadegrays8_transition : fadegrays16_transition; break;
2144		✗	case WIPETL: s->transitionf = s->depth <= 8 ? wipetl8_transition : wipetl16_transition; break;
2145		✗	case WIPETR: s->transitionf = s->depth <= 8 ? wipetr8_transition : wipetr16_transition; break;
2146		✗	case WIPEBL: s->transitionf = s->depth <= 8 ? wipebl8_transition : wipebl16_transition; break;
2147		✗	case WIPEBR: s->transitionf = s->depth <= 8 ? wipebr8_transition : wipebr16_transition; break;
2148		✗	case SQUEEZEH: s->transitionf = s->depth <= 8 ? squeezeh8_transition : squeezeh16_transition; break;
2149		✗	case SQUEEZEV: s->transitionf = s->depth <= 8 ? squeezev8_transition : squeezev16_transition; break;
2150		✗	case ZOOMIN: s->transitionf = s->depth <= 8 ? zoomin8_transition : zoomin16_transition; break;
2151		✗	case FADEFAST: s->transitionf = s->depth <= 8 ? fadefast8_transition : fadefast16_transition; break;
2152		✗	case FADESLOW: s->transitionf = s->depth <= 8 ? fadeslow8_transition : fadeslow16_transition; break;
2153		✗	case HLWIND: s->transitionf = s->depth <= 8 ? hlwind8_transition : hlwind16_transition; break;
2154		✗	case HRWIND: s->transitionf = s->depth <= 8 ? hrwind8_transition : hrwind16_transition; break;
2155		✗	case VUWIND: s->transitionf = s->depth <= 8 ? vuwind8_transition : vuwind16_transition; break;
2156		✗	case VDWIND: s->transitionf = s->depth <= 8 ? vdwind8_transition : vdwind16_transition; break;
2157		✗	case COVERLEFT: s->transitionf = s->depth <= 8 ? coverleft8_transition : coverleft16_transition; break;
2158		✗	case COVERRIGHT: s->transitionf = s->depth <= 8 ? coverright8_transition : coverright16_transition; break;
2159		✗	case COVERUP: s->transitionf = s->depth <= 8 ? coverup8_transition : coverup16_transition; break;
2160		✗	case COVERDOWN: s->transitionf = s->depth <= 8 ? coverdown8_transition : coverdown16_transition; break;
2161		✗	case REVEALLEFT: s->transitionf = s->depth <= 8 ? revealleft8_transition : revealleft16_transition; break;
2162		✗	case REVEALRIGHT:s->transitionf = s->depth <= 8 ? revealright8_transition: revealright16_transition;break;
2163		✗	case REVEALUP: s->transitionf = s->depth <= 8 ? revealup8_transition : revealup16_transition; break;
2164		✗	case REVEALDOWN: s->transitionf = s->depth <= 8 ? revealdown8_transition : revealdown16_transition; break;
2165		✗	default: return AVERROR_BUG;
2166			}
2167
2168		✗	if (s->transition == CUSTOM) {
2169			static const char *const func2_names[] = {
2170			"a0", "a1", "a2", "a3",
2171			"b0", "b1", "b2", "b3",
2172			NULL
2173			};
2174		✗	double (*func2[])(void *, double, double) = {
2175			a0, a1, a2, a3,
2176			b0, b1, b2, b3,
2177			NULL };
2178			int ret;
2179
2180		✗	if (!s->custom_str)
2181		✗	return AVERROR(EINVAL);
2182		✗	ret = av_expr_parse(&s->e, s->custom_str, var_names,
2183			NULL, NULL, func2_names, func2, 0, ctx);
2184		✗	if (ret < 0)
2185		✗	return ret;
2186			}
2187
2188		✗	return 0;
2189			}
2190
2191		✗	static int xfade_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
2192			{
2193		✗	XFadeContext *s = ctx->priv;
2194		✗	AVFilterLink *outlink = ctx->outputs[0];
2195		✗	ThreadData *td = arg;
2196		✗	int slice_start = (outlink->h * jobnr ) / nb_jobs;
2197		✗	int slice_end = (outlink->h * (jobnr+1)) / nb_jobs;
2198
2199		✗	s->transitionf(ctx, td->xf[0], td->xf[1], td->out, td->progress, slice_start, slice_end, jobnr);
2200
2201		✗	return 0;
2202			}
2203
2204		✗	static int xfade_frame(AVFilterContext *ctx, AVFrame *a, AVFrame *b)
2205			{
2206		✗	XFadeContext *s = ctx->priv;
2207		✗	AVFilterLink *outlink = ctx->outputs[0];
2208		✗	float progress = av_clipf(1.f - ((float)(s->pts - s->start_pts) / s->duration_pts), 0.f, 1.f);
2209			ThreadData td;
2210			AVFrame *out;
2211
2212		✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
2213		✗	if (!out)
2214		✗	return AVERROR(ENOMEM);
2215		✗	av_frame_copy_props(out, a);
2216
2217		✗	td.xf[0] = a, td.xf[1] = b, td.out = out, td.progress = progress;
2218		✗	ff_filter_execute(ctx, xfade_slice, &td, NULL,
2219		✗	FFMIN(outlink->h, ff_filter_get_nb_threads(ctx)));
2220
2221		✗	out->pts = s->pts;
2222
2223		✗	return ff_filter_frame(outlink, out);
2224			}
2225
2226		✗	static int forward_frame(XFadeContext *s,
2227			AVFilterLink *inlink, AVFilterLink *outlink)
2228			{
2229			int64_t status_pts;
2230		✗	int ret = 0, status;
2231		✗	AVFrame *frame = NULL;
2232
2233		✗	ret = ff_inlink_consume_frame(inlink, &frame);
2234		✗	if (ret < 0)
2235		✗	return ret;
2236
2237		✗	if (ret > 0) {
2238			// If we do not have an offset yet, it's because we
2239			// never got a first input. Just offset to 0
2240		✗	if (s->inputs_offset_pts == AV_NOPTS_VALUE)
2241		✗	s->inputs_offset_pts = -frame->pts;
2242
2243			// We got a frame, nothing to do other than adjusting the timestamp
2244		✗	frame->pts += s->inputs_offset_pts;
2245		✗	return ff_filter_frame(outlink, frame);
2246			}
2247
2248			// Forward status with our timestamp
2249		✗	if (ff_inlink_acknowledge_status(inlink, &status, &status_pts)) {
2250		✗	if (s->inputs_offset_pts == AV_NOPTS_VALUE)
2251		✗	s->inputs_offset_pts = -status_pts;
2252
2253		✗	ff_outlink_set_status(outlink, status, status_pts + s->inputs_offset_pts);
2254		✗	return 0;
2255			}
2256
2257			// No frame available, request one if needed
2258		✗	if (ff_outlink_frame_wanted(outlink))
2259		✗	ff_inlink_request_frame(inlink);
2260
2261		✗	return 0;
2262			}
2263
2264		✗	static int xfade_activate(AVFilterContext *avctx)
2265			{
2266		✗	XFadeContext *s = avctx->priv;
2267		✗	AVFilterLink *in_a = avctx->inputs[0];
2268		✗	AVFilterLink *in_b = avctx->inputs[1];
2269		✗	AVFilterLink *outlink = avctx->outputs[0];
2270			int64_t status_pts;
2271
2272		✗	FF_FILTER_FORWARD_STATUS_BACK_ALL(outlink, avctx);
2273
2274			// Check if we already transitioned or first input ended prematurely,
2275			// in which case just forward the frames from second input with adjusted
2276			// timestamps until EOF.
2277		✗	if (s->status[0] && !s->status[1])
2278		✗	return forward_frame(s, in_b, outlink);
2279
2280			// We did not finish transitioning yet and the first stream
2281			// did not end either, so check if there are more frames to consume.
2282		✗	if (ff_inlink_check_available_frame(in_a)) {
2283		✗	AVFrame *peeked_frame = ff_inlink_peek_frame(in_a, 0);
2284		✗	s->pts = peeked_frame->pts;
2285
2286		✗	if (s->start_pts == AV_NOPTS_VALUE)
2287		✗	s->start_pts =
2288		✗	s->pts + av_rescale_q(s->offset, AV_TIME_BASE_Q, in_a->time_base);
2289
2290			// Check if we are not yet transitioning, in which case
2291			// just request and forward the input frame.
2292		✗	if (s->start_pts > s->pts) {
2293			int ret;
2294		✗	s->passthrough = 1;
2295		✗	ret = ff_inlink_consume_frame(in_a, &s->xf[0]);
2296		✗	if (ret < 0)
2297		✗	return ret;
2298		✗	return ff_filter_frame(outlink, s->xf[0]);
2299			}
2300		✗	s->passthrough = 0;
2301
2302			// We are transitioning, so we need a frame from second input
2303		✗	if (ff_inlink_check_available_frame(in_b)) {
2304			int ret;
2305		✗	ret = ff_inlink_consume_frame(avctx->inputs[0], &s->xf[0]);
2306		✗	if (ret < 0)
2307		✗	return ret;
2308		✗	ret = ff_inlink_consume_frame(avctx->inputs[1], &s->xf[1]);
2309		✗	if (ret < 0) {
2310		✗	av_frame_free(&s->xf[0]);
2311		✗	return ret;
2312			}
2313
2314			// Calculate PTS offset to first input
2315		✗	if (s->inputs_offset_pts == AV_NOPTS_VALUE)
2316		✗	s->inputs_offset_pts = s->pts - s->xf[1]->pts;
2317
2318			// Check if we finished transitioning, in which case we
2319			// report back EOF to first input as it is no longer needed.
2320		✗	if (s->pts - s->start_pts > s->duration_pts) {
2321		✗	s->status[0] = AVERROR_EOF;
2322		✗	ff_inlink_set_status(in_a, AVERROR_EOF);
2323		✗	s->passthrough = 1;
2324			}
2325		✗	ret = xfade_frame(avctx, s->xf[0], s->xf[1]);
2326		✗	av_frame_free(&s->xf[0]);
2327		✗	av_frame_free(&s->xf[1]);
2328		✗	return ret;
2329			}
2330
2331			// We did not get a frame from second input, check its status.
2332		✗	if (ff_inlink_acknowledge_status(in_b, &s->status[1], &status_pts)) {
2333			// We should transition, but second input is EOF so just report EOF output now.
2334		✗	ff_outlink_set_status(outlink, s->status[1], s->pts);
2335		✗	return 0;
2336			}
2337
2338			// We did not get a frame for second input but no EOF either, so just request more.
2339		✗	if (ff_outlink_frame_wanted(outlink)) {
2340		✗	ff_inlink_request_frame(in_b);
2341		✗	return 0;
2342			}
2343			}
2344
2345			// We did not get a frame from first input, check its status.
2346		✗	if (ff_inlink_acknowledge_status(in_a, &s->status[0], &status_pts)) {
2347			// No more frames from first input, do not report EOF though, we will just
2348			// forward the second input frames in the next activate calls.
2349		✗	s->passthrough = 1;
2350		✗	ff_filter_set_ready(avctx, 100);
2351		✗	return 0;
2352			}
2353
2354			// We have no frames yet from first input and no EOF, so request some.
2355		✗	if (ff_outlink_frame_wanted(outlink)) {
2356		✗	ff_inlink_request_frame(in_a);
2357		✗	return 0;
2358			}
2359
2360		✗	return FFERROR_NOT_READY;
2361			}
2362
2363		✗	static AVFrame *get_video_buffer(AVFilterLink *inlink, int w, int h)
2364			{
2365		✗	XFadeContext *s = inlink->dst->priv;
2366
2367		✗	return s->passthrough ?
2368		✗	ff_null_get_video_buffer (inlink, w, h) :
2369		✗	ff_default_get_video_buffer(inlink, w, h);
2370			}
2371
2372			static const AVFilterPad xfade_inputs[] = {
2373			{
2374			.name = "main",
2375			.type = AVMEDIA_TYPE_VIDEO,
2376			.get_buffer.video = get_video_buffer,
2377			},
2378			{
2379			.name = "xfade",
2380			.type = AVMEDIA_TYPE_VIDEO,
2381			.get_buffer.video = get_video_buffer,
2382			},
2383			};
2384
2385			static const AVFilterPad xfade_outputs[] = {
2386			{
2387			.name = "default",
2388			.type = AVMEDIA_TYPE_VIDEO,
2389			.config_props = config_output,
2390			},
2391			};
2392
2393			const FFFilter ff_vf_xfade = {
2394			.p.name = "xfade",
2395			.p.description = NULL_IF_CONFIG_SMALL("Cross fade one video with another video."),
2396			.p.priv_class = &xfade_class,
2397			.p.flags = AVFILTER_FLAG_SLICE_THREADS,
2398			.priv_size = sizeof(XFadeContext),
2399			.activate = xfade_activate,
2400			.uninit = uninit,
2401			FILTER_INPUTS(xfade_inputs),
2402			FILTER_OUTPUTS(xfade_outputs),
2403			FILTER_PIXFMTS_ARRAY(pix_fmts),
2404			};
2405