FFmpeg
Loading...
Searching...
No Matches
Data Structures | Macros | Enumerations | Functions | Variables
vf_xfade.c File Reference
#include "libavutil/eval.h"
#include "libavutil/opt.h"
#include "libavutil/pixdesc.h"
#include "libavutil/pixfmt.h"
#include "avfilter.h"
#include "filters.h"
#include "video.h"

Go to the source code of this file.

Data Structures

struct  XFadeContext
 
struct  ThreadData
 Used for passing data between threads. More...
 

Macros

#define OFFSET(x)
 
#define FLAGS   (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
 
#define CUSTOM_TRANSITION(name, type, div)
 
#define FADE_TRANSITION(name, type, div)
 
#define WIPELEFT_TRANSITION(name, type, div)
 
#define WIPERIGHT_TRANSITION(name, type, div)
 
#define WIPEUP_TRANSITION(name, type, div)
 
#define WIPEDOWN_TRANSITION(name, type, div)
 
#define SLIDELEFT_TRANSITION(name, type, div)
 
#define SLIDERIGHT_TRANSITION(name, type, div)
 
#define SLIDEUP_TRANSITION(name, type, div)
 
#define SLIDEDOWN_TRANSITION(name, type, div)
 
#define CIRCLECROP_TRANSITION(name, type, div)
 
#define RECTCROP_TRANSITION(name, type, div)
 
#define DISTANCE_TRANSITION(name, type, div)
 
#define FADEBLACK_TRANSITION(name, type, div)
 
#define FADEWHITE_TRANSITION(name, type, div)
 
#define RADIAL_TRANSITION(name, type, div)
 
#define SMOOTHLEFT_TRANSITION(name, type, div)
 
#define SMOOTHRIGHT_TRANSITION(name, type, div)
 
#define SMOOTHUP_TRANSITION(name, type, div)
 
#define SMOOTHDOWN_TRANSITION(name, type, div)
 
#define CIRCLEOPEN_TRANSITION(name, type, div)
 
#define CIRCLECLOSE_TRANSITION(name, type, div)
 
#define VERTOPEN_TRANSITION(name, type, div)
 
#define VERTCLOSE_TRANSITION(name, type, div)
 
#define HORZOPEN_TRANSITION(name, type, div)
 
#define HORZCLOSE_TRANSITION(name, type, div)
 
#define DISSOLVE_TRANSITION(name, type, div)
 
#define PIXELIZE_TRANSITION(name, type, div)
 
#define DIAGTL_TRANSITION(name, type, div)
 
#define DIAGTR_TRANSITION(name, type, div)
 
#define DIAGBL_TRANSITION(name, type, div)
 
#define DIAGBR_TRANSITION(name, type, div)
 
#define HLSLICE_TRANSITION(name, type, div)
 
#define HRSLICE_TRANSITION(name, type, div)
 
#define VUSLICE_TRANSITION(name, type, div)
 
#define VDSLICE_TRANSITION(name, type, div)
 
#define HBLUR_TRANSITION(name, type, div)
 
#define FADEGRAYS_TRANSITION(name, type, div)
 
#define WIPETL_TRANSITION(name, type, div)
 
#define WIPETR_TRANSITION(name, type, div)
 
#define WIPEBL_TRANSITION(name, type, div)
 
#define WIPEBR_TRANSITION(name, type, div)
 
#define SQUEEZEH_TRANSITION(name, type, div)
 
#define SQUEEZEV_TRANSITION(name, type, div)
 
#define ZOOMIN_TRANSITION(name, type, div)
 
#define FADEFAST_TRANSITION(name, type, div)
 
#define FADESLOW_TRANSITION(name, type, div)
 
#define HWIND_TRANSITION(name, z, type, div, expr)
 
#define VWIND_TRANSITION(name, z, type, div, expr)
 
#define COVERH_TRANSITION(dir, name, type, div, expr)
 
#define COVERV_TRANSITION(dir, name, type, div, expr)
 
#define REVEALH_TRANSITION(dir, name, type, div, expr)
 
#define REVEALV_TRANSITION(dir, name, type, div, expr)
 

Enumerations

enum  XFadeTransitions {
  CUSTOM = -1 , FADE , WIPELEFT , WIPERIGHT ,
  WIPEUP , WIPEDOWN , SLIDELEFT , SLIDERIGHT ,
  SLIDEUP , SLIDEDOWN , CIRCLECROP , RECTCROP ,
  DISTANCE , FADEBLACK , FADEWHITE , RADIAL ,
  SMOOTHLEFT , SMOOTHRIGHT , SMOOTHUP , SMOOTHDOWN ,
  CIRCLEOPEN , CIRCLECLOSE , VERTOPEN , VERTCLOSE ,
  HORZOPEN , HORZCLOSE , DISSOLVE , PIXELIZE ,
  DIAGTL , DIAGTR , DIAGBL , DIAGBR ,
  HLSLICE , HRSLICE , VUSLICE , VDSLICE ,
  HBLUR , FADEGRAYS , WIPETL , WIPETR ,
  WIPEBL , WIPEBR , SQUEEZEH , SQUEEZEV ,
  ZOOMIN , FADEFAST , FADESLOW , HLWIND ,
  HRWIND , VUWIND , VDWIND , COVERLEFT ,
  COVERRIGHT , COVERUP , COVERDOWN , REVEALLEFT ,
  REVEALRIGHT , REVEALUP , REVEALDOWN , NB_TRANSITIONS
}
 
enum  {
  VAR_X , VAR_Y , VAR_W , VAR_H ,
  VAR_A , VAR_B , VAR_PLANE , VAR_PROGRESS ,
  VAR_VARS_NB
}
 

Functions

static av_cold void uninit (AVFilterContext *ctx)
 
 AVFILTER_DEFINE_CLASS (xfade)
 
static float mix (float a, float b, float mix)
 
static float fract (float a)
 
static float smoothstep (float edge0, float edge1, float x)
 
static float frand (int x, int y)
 
static void zoom (float *u, float *v, float amount)
 
static double getpix (void *priv, double x, double y, int plane, int nb)
 
static double a0 (void *priv, double x, double y)
 
static double a1 (void *priv, double x, double y)
 
static double a2 (void *priv, double x, double y)
 
static double a3 (void *priv, double x, double y)
 
static double b0 (void *priv, double x, double y)
 
static double b1 (void *priv, double x, double y)
 
static double b2 (void *priv, double x, double y)
 
static double b3 (void *priv, double x, double y)
 
static int config_output (AVFilterLink *outlink)
 
static int xfade_slice (AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
 
static int xfade_frame (AVFilterContext *ctx, AVFrame *a, AVFrame *b)
 
static int forward_frame (XFadeContext *s, AVFilterLink *inlink, AVFilterLink *outlink)
 
static int xfade_activate (AVFilterContext *avctx)
 
static AVFrame * get_video_buffer (AVFilterLink *inlink, int w, int h)
 

Variables

static const char *const var_names [] = { "X", "Y", "W", "H", "A", "B", "PLANE", "P", NULL }
 
static enum AVPixelFormat pix_fmts []
 
static const AVOption xfade_options []
 
static const AVFilterPad xfade_inputs []
 
static const AVFilterPad xfade_outputs []
 
const FFFilter ff_vf_xfade
 

Macro Definition Documentation

◆ OFFSET

#define OFFSET ( x)
Value:
offsetof(XFadeContext, x)

Definition at line 167 of file vf_xfade.c.

◆ FLAGS

#define FLAGS   (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)

Definition at line 168 of file vf_xfade.c.

◆ CUSTOM_TRANSITION

#define CUSTOM_TRANSITION ( name,
type,
div )

Definition at line 239 of file vf_xfade.c.

◆ FADE_TRANSITION

#define FADE_TRANSITION ( name,
type,
div )
Value:
static void fade##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = mix(xf0[x], xf1[x], progress); \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition dsp.h:87
s
#define s(width, name)
Definition cbs_vp9.c:198
a
int a
Definition h264pred_template.c:416
type
cl_device_type type
Definition hwcontext_opencl.c:213
b
#define b
Definition input.c:43
mix
static int mix(int c0, int c1)
Definition 4xm.c:717
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
Definition mpeg12dec.c:1697
name
const char * name
Definition qsvenc.c:142
AVFilterContext
An instance of a filter.
Definition avfilter.h:273
AVFrame
This structure describes decoded (raw) audio or video data.
Definition frame.h:472
out
static FILE * out
Definition movenc.c:55
ctx
static AVFormatContext * ctx
Definition movenc.c:49
height
#define height
Definition dsp.h:89
width
#define width
Definition dsp.h:89
fade
static void fade(uint8_t *dst, ptrdiff_t dst_linesize, const uint8_t *src, ptrdiff_t src_linesize, int width, int height, int alpha, int beta)
Definition vp8.c:512
slice_start
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
Definition dec.c:844

Definition at line 299 of file vf_xfade.c.

◆ WIPELEFT_TRANSITION

#define WIPELEFT_TRANSITION ( name,
type,
div )
Value:
static void wipeleft##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = width * progress; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = x > z ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 329 of file vf_xfade.c.

◆ WIPERIGHT_TRANSITION

#define WIPERIGHT_TRANSITION ( name,
type,
div )
Value:
static void wiperight##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = width * (1.f - progress); \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = x > z ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 360 of file vf_xfade.c.

◆ WIPEUP_TRANSITION

#define WIPEUP_TRANSITION ( name,
type,
div )
Value:
static void wipeup##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = out->height * progress; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y > z ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 391 of file vf_xfade.c.

◆ WIPEDOWN_TRANSITION

#define WIPEDOWN_TRANSITION ( name,
type,
div )
Value:
static void wipedown##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = out->height * (1.f - progress); \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y > z ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 422 of file vf_xfade.c.

◆ SLIDELEFT_TRANSITION

#define SLIDELEFT_TRANSITION ( name,
type,
div )
Value:
static void slideleft##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = -progress * width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
const int zx = z + x; \
const int zz = zx % width + width * (zx < 0); \
dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 453 of file vf_xfade.c.

◆ SLIDERIGHT_TRANSITION

#define SLIDERIGHT_TRANSITION ( name,
type,
div )
Value:
static void slideright##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = progress * width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
const int zx = z + x; \
const int zz = zx % width + width * (zx < 0); \
dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[zz]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 486 of file vf_xfade.c.

◆ SLIDEUP_TRANSITION

#define SLIDEUP_TRANSITION ( name,
type,
div )
Value:
static void slideup##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = out->height; \
const int width = out->width; \
const int z = -progress * height; \
\
for (int p = 0; p < s->nb_planes; p++) { \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const int zy = z + y; \
const int zz = zy % height + height * (zy < 0); \
const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
\
for (int x = 0; x < width; x++) { \
dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}

Definition at line 519 of file vf_xfade.c.

◆ SLIDEDOWN_TRANSITION

#define SLIDEDOWN_TRANSITION ( name,
type,
div )
Value:
static void slidedown##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = out->height; \
const int width = out->width; \
const int z = progress * height; \
\
for (int p = 0; p < s->nb_planes; p++) { \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const int zy = z + y; \
const int zz = zy % height + height * (zy < 0); \
const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
\
for (int x = 0; x < width; x++) { \
dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}

Definition at line 551 of file vf_xfade.c.

◆ CIRCLECROP_TRANSITION

#define CIRCLECROP_TRANSITION ( name,
type,
div )
Value:
static void circlecrop##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const int height = out->height; \
float z = powf(2.f * fabsf(progress - 0.5f), 3.f) * hypotf(width/2, height/2); \
\
for (int p = 0; p < s->nb_planes; p++) { \
const int bg = s->black[p]; \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
\
for (int x = 0; x < width; x++) { \
float dist = hypotf(x - width / 2, y - height / 2); \
int val = progress < 0.5f ? xf1[x] : xf0[x]; \
dst[x] = (z < dist) ? bg : val; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}
val
static double val(void *priv, double ch)
Definition aeval.c:77
fabsf
static __device__ float fabsf(float a)
Definition cuda_runtime.h:181
powf
#define powf(x, y)
Definition libm.h:52

Definition at line 583 of file vf_xfade.c.

◆ RECTCROP_TRANSITION

#define RECTCROP_TRANSITION ( name,
type,
div )
Value:
static void rectcrop##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const int height = out->height; \
int zh = fabsf(progress - 0.5f) * height; \
int zw = fabsf(progress - 0.5f) * width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const int bg = s->black[p]; \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
\
for (int x = 0; x < width; x++) { \
int dist = FFABS(x - width / 2) < zw && \
FFABS(y - height / 2) < zh; \
int val = progress < 0.5f ? xf1[x] : xf0[x]; \
dst[x] = !dist ? bg : val; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition common.h:74

Definition at line 616 of file vf_xfade.c.

◆ DISTANCE_TRANSITION

#define DISTANCE_TRANSITION ( name,
type,
div )
Value:
static void distance##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float max = s->max_value; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
float dist = 0.f; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
\
dist += (xf0[x] / max - xf1[x] / max) * \
(xf0[x] / max - xf1[x] / max); \
} \
\
dist = sqrtf(dist) <= progress; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
dst[x] = mix(mix(xf0[x], xf1[x], dist), xf1[x], progress); \
} \
} \
} \
}
sqrtf
static __device__ float sqrtf(float a)
Definition cuda_runtime.h:184
max
#define max(a, b)
Definition cuda_runtime.h:33
distance
static float distance(float x, float y, int band)
Definition nellymoserenc.c:231

Definition at line 651 of file vf_xfade.c.

◆ FADEBLACK_TRANSITION

#define FADEBLACK_TRANSITION ( name,
type,
div )
Value:
static void fadeblack##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const float phase = 0.2f; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
const int bg = s->black[p]; \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
progress); \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}
smoothstep
static float smoothstep(float edge0, float edge1, float x)
Definition vf_xfade.c:290

Definition at line 686 of file vf_xfade.c.

◆ FADEWHITE_TRANSITION

#define FADEWHITE_TRANSITION ( name,
type,
div )
Value:
static void fadewhite##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const float phase = 0.2f; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
const int bg = s->white[p]; \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = mix(mix(xf0[x], bg, smoothstep(1.f-phase, 1.f, progress)), \
mix(bg, xf1[x], smoothstep(phase, 1.f, progress)), \
progress); \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 720 of file vf_xfade.c.

◆ RADIAL_TRANSITION

#define RADIAL_TRANSITION ( name,
type,
div )
Value:
static void radial##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const int height = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = atan2f(x - width / 2, y - height / 2) - \
(progress - 0.5f) * (M_PI * 2.5f); \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}
atan2f
#define atan2f(y, x)
Definition libm.h:47
M_PI
#define M_PI
Definition mathematics.h:67
smooth
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifo *values)
Definition vf_deshake_opencl.c:887

Definition at line 754 of file vf_xfade.c.

◆ SMOOTHLEFT_TRANSITION

#define SMOOTHLEFT_TRANSITION ( name,
type,
div )
Value:
static void smoothleft##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float w = width; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + x / w - progress * 2.f; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}
w
uint8_t w
Definition llvidencdsp.c:39

Definition at line 782 of file vf_xfade.c.

◆ SMOOTHRIGHT_TRANSITION

#define SMOOTHRIGHT_TRANSITION ( name,
type,
div )
Value:
static void smoothright##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float w = width; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + (w - 1 - x) / w - progress * 2.f; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 810 of file vf_xfade.c.

◆ SMOOTHUP_TRANSITION

#define SMOOTHUP_TRANSITION ( name,
type,
div )
Value:
static void smoothup##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float smooth = 1.f + y / h - progress * 2.f; \
for (int x = 0; x < width; x++) { \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}
h
h
Definition vp9dsp_template.c:2070

Definition at line 838 of file vf_xfade.c.

◆ SMOOTHDOWN_TRANSITION

#define SMOOTHDOWN_TRANSITION ( name,
type,
div )
Value:
static void smoothdown##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float smooth = 1.f + (h - 1 - y) / h - progress * 2.f; \
for (int x = 0; x < width; x++) { \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 865 of file vf_xfade.c.

◆ CIRCLEOPEN_TRANSITION

#define CIRCLEOPEN_TRANSITION ( name,
type,
div )
Value:
static void circleopen##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const int height = out->height; \
const float z = hypotf(width / 2, height / 2); \
const float p = (progress - 0.5f) * 3.f; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = hypotf(x - width / 2, y - height / 2) / z + p; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf0[x], xf1[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 892 of file vf_xfade.c.

◆ CIRCLECLOSE_TRANSITION

#define CIRCLECLOSE_TRANSITION ( name,
type,
div )
Value:
static void circleclose##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const int height = out->height; \
const float z = hypotf(width / 2, height / 2); \
const float p = (1.f - progress - 0.5f) * 3.f; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = hypotf(x - width / 2, y - height / 2) / z + p; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 921 of file vf_xfade.c.

◆ VERTOPEN_TRANSITION

#define VERTOPEN_TRANSITION ( name,
type,
div )
Value:
static void vertopen##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
const float w2 = out->width / 2.0; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 2.f - fabsf((x - w2) / w2) - progress * 2.f; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 950 of file vf_xfade.c.

◆ VERTCLOSE_TRANSITION

#define VERTCLOSE_TRANSITION ( name,
type,
div )
Value:
static void vertclose##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w2 = out->width / 2.0; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + fabsf((x - w2) / w2) - progress * 2.f; \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 977 of file vf_xfade.c.

◆ HORZOPEN_TRANSITION

#define HORZOPEN_TRANSITION ( name,
type,
div )
Value:
static void horzopen##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float h2 = out->height / 2.0; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float smooth = 2.f - fabsf((y - h2) / h2) - progress * 2.f; \
for (int x = 0; x < width; x++) { \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1005 of file vf_xfade.c.

◆ HORZCLOSE_TRANSITION

#define HORZCLOSE_TRANSITION ( name,
type,
div )
Value:
static void horzclose##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float h2 = out->height / 2.0; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float smooth = 1.f + fabsf((y - h2) / h2) - progress * 2.f; \
for (int x = 0; x < width; x++) { \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1033 of file vf_xfade.c.

◆ DISSOLVE_TRANSITION

#define DISSOLVE_TRANSITION ( name,
type,
div )
Value:
static void dissolve##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = frand(x, y) * 2.f + progress * 2.f - 1.5f; \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = smooth >= 0.5f ? xf0[x] : xf1[x]; \
} \
} \
} \
}
frand
static float frand(int x, int y)
Definition vf_deband.c:119

Definition at line 1068 of file vf_xfade.c.

◆ PIXELIZE_TRANSITION

#define PIXELIZE_TRANSITION ( name,
type,
div )
Value:
static void pixelize##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int w = out->width; \
const int h = out->height; \
const float d = fminf(progress, 1.f - progress); \
const float dist = ceilf(d * 50.f) / 50.f; \
const float sqx = 2.f * dist * FFMIN(w, h) / 20.f; \
const float sqy = 2.f * dist * FFMIN(w, h) / 20.f; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < w; x++) { \
int sx = dist > 0.f ? FFMIN((floorf(x / sqx) + .5f) * sqx, w - 1) : x; \
int sy = dist > 0.f ? FFMIN((floorf(y / sqy) + .5f) * sqy, h - 1) : y; \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + sy * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + sy * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf0[sx], xf1[sx], progress); \
} \
} \
} \
}
floorf
static __device__ float floorf(float a)
Definition cuda_runtime.h:172
ceilf
static __device__ float ceilf(float a)
Definition cuda_runtime.h:175
fminf
float fminf(float, float)
FFMIN
#define FFMIN(a, b)
Definition macros.h:49

Definition at line 1095 of file vf_xfade.c.

◆ DIAGTL_TRANSITION

#define DIAGTL_TRANSITION ( name,
type,
div )
Value:
static void diagtl##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + x / w * y / h - progress * 2.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1128 of file vf_xfade.c.

◆ DIAGTR_TRANSITION

#define DIAGTR_TRANSITION ( name,
type,
div )
Value:
static void diagtr##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + (w - 1 - x) / w * y / h - progress * 2.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1158 of file vf_xfade.c.

◆ DIAGBL_TRANSITION

#define DIAGBL_TRANSITION ( name,
type,
div )
Value:
static void diagbl##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + x / w * (h - 1 - y) / h - progress * 2.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1188 of file vf_xfade.c.

◆ DIAGBR_TRANSITION

#define DIAGBR_TRANSITION ( name,
type,
div )
Value:
static void diagbr##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = 1.f + (w - 1 - x) / w * (h - 1 - y) / h - \
progress * 2.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f, 1.f, smooth)); \
} \
} \
} \
}

Definition at line 1218 of file vf_xfade.c.

◆ HLSLICE_TRANSITION

#define HLSLICE_TRANSITION ( name,
type,
div )
Value:
static void hlslice##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float smooth = smoothstep(-0.5f, 0.f, x / w - progress * 1.5f); \
const float ss = smooth <= fract(10.f * x / w) ? 0.f : 1.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], ss); \
} \
} \
} \
}
ss
#define ss(width, name, subs,...)
Definition cbs_vp9.c:202
fract
static float fract(float a)
Definition vf_xfade.c:285

Definition at line 1249 of file vf_xfade.c.

◆ HRSLICE_TRANSITION

#define HRSLICE_TRANSITION ( name,
type,
div )
Value:
static void hrslice##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float w = width; \
\
for (int y = slice_start; y < slice_end; y++) { \
for (int x = 0; x < width; x++) { \
const float xx = (w - 1 - x) / w; \
const float smooth = smoothstep(-0.5f, 0.f, xx - progress * 1.5f); \
const float ss = smooth <= fract(10.f * xx) ? 0.f : 1.f; \
\
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], ss); \
} \
} \
} \
}

Definition at line 1279 of file vf_xfade.c.

◆ VUSLICE_TRANSITION

#define VUSLICE_TRANSITION ( name,
type,
div )
Value:
static void vuslice##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float smooth = smoothstep(-0.5f, 0.f, y / h - progress * 1.5f); \
const float ss = smooth <= fract(10.f * y / h) ? 0.f : 1.f; \
\
for (int x = 0; x < width; x++) { \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], ss); \
} \
} \
} \
}

Definition at line 1310 of file vf_xfade.c.

◆ VDSLICE_TRANSITION

#define VDSLICE_TRANSITION ( name,
type,
div )
Value:
static void vdslice##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int nb_planes = s->nb_planes; \
const int width = out->width; \
const float h = out->height; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float yy = (h - 1 - y) / h; \
const float smooth = smoothstep(-0.5f, 0.f, yy - progress * 1.5f); \
const float ss = smooth <= fract(10.f * yy) ? 0.f : 1.f; \
\
for (int x = 0; x < width; x++) { \
for (int p = 0; p < nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], ss); \
} \
} \
} \
}

Definition at line 1340 of file vf_xfade.c.

◆ HBLUR_TRANSITION

#define HBLUR_TRANSITION ( name,
type,
div )

Definition at line 1371 of file vf_xfade.c.

◆ FADEGRAYS_TRANSITION

#define FADEGRAYS_TRANSITION ( name,
type,
div )

Definition at line 1416 of file vf_xfade.c.

◆ WIPETL_TRANSITION

#define WIPETL_TRANSITION ( name,
type,
div )
Value:
static void wipetl##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int zw = out->width * progress; \
const int zh = out->height * progress; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y <= zh && \
x <= zw ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1486 of file vf_xfade.c.

◆ WIPETR_TRANSITION

#define WIPETR_TRANSITION ( name,
type,
div )
Value:
static void wipetr##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int zw = width * (1.f - progress); \
const int zh = out->height * progress; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y <= zh && \
x > zw ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1519 of file vf_xfade.c.

◆ WIPEBL_TRANSITION

#define WIPEBL_TRANSITION ( name,
type,
div )
Value:
static void wipebl##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int zw = width * progress; \
const int zh = out->height * (1.f - progress); \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y > zh && \
x <= zw ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1552 of file vf_xfade.c.

◆ WIPEBR_TRANSITION

#define WIPEBR_TRANSITION ( name,
type,
div )
Value:
static void wipebr##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int zh = out->height * (1.f - progress); \
const int width = out->width; \
const int zw = width * (1.f - progress); \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = slice_start + y > zh && \
x > zw ? xf0[x] : xf1[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1585 of file vf_xfade.c.

◆ SQUEEZEH_TRANSITION

#define SQUEEZEH_TRANSITION ( name,
type,
div )

Definition at line 1618 of file vf_xfade.c.

◆ SQUEEZEV_TRANSITION

#define SQUEEZEV_TRANSITION ( name,
type,
div )

Definition at line 1656 of file vf_xfade.c.

◆ ZOOMIN_TRANSITION

#define ZOOMIN_TRANSITION ( name,
type,
div )

Definition at line 1701 of file vf_xfade.c.

◆ FADEFAST_TRANSITION

#define FADEFAST_TRANSITION ( name,
type,
div )
Value:
static void fadefast##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const float imax = 1.f / s->max_value; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = mix(xf0[x], xf1[x], powf(progress, 1.f + \
logf(1.f+FFABS(xf0[x]-xf1[x])*imax)\
)); \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}
imax
static int imax(const int a, const int b)
Definition internal.h:177

Definition at line 1740 of file vf_xfade.c.

◆ FADESLOW_TRANSITION

#define FADESLOW_TRANSITION ( name,
type,
div )
Value:
static void fadeslow##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const float imax = 1.f / s->max_value; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
dst[x] = mix(xf0[x], xf1[x], powf(progress, 1.f + \
logf(2.f-FFABS(xf0[x]-xf1[x])*imax)\
)); \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1773 of file vf_xfade.c.

◆ HWIND_TRANSITION

#define HWIND_TRANSITION ( name,
z,
type,
div,
expr )
Value:
static void h##z##wind##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float r = frand(0, y); \
for (int x = 0; x < width; x++) { \
const float fx = expr x / (float)width; \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f,-0.2f, fx * (1.f - 0.2f)\
+ 0.2f * r - (1.f - progress)\
* (1.f + 0.2f))); \
} \
} \
} \
}
float
float
Definition af_crystalizer.c:122
r
#define r
Definition input.c:42

Definition at line 1806 of file vf_xfade.c.

◆ VWIND_TRANSITION

#define VWIND_TRANSITION ( name,
z,
type,
div,
expr )
Value:
static void v##z##wind##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int width = out->width; \
\
for (int y = slice_start; y < slice_end; y++) { \
const float fy = expr y / (float)out->height; \
for (int x = 0; x < width; x++) { \
const float r = frand(x, 0); \
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
type *dst = (type *)(out->data[p] + y * out->linesize[p]); \
\
dst[x] = mix(xf1[x], xf0[x], smoothstep(0.f,-0.2f, fy * (1.f - 0.2f) \
+ 0.2f * r - (1.f - progress)\
* (1.f + 0.2f))); \
} \
} \
} \
}

Definition at line 1837 of file vf_xfade.c.

◆ COVERH_TRANSITION

#define COVERH_TRANSITION ( dir,
name,
type,
div,
expr )
Value:
static void cover##dir##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = (expr progress) * width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
const int zx = z + x; \
const int zz = zx % width + width * (zx < 0); \
dst[x] = (zx >= 0) && (zx < width) ? xf1[zz] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1868 of file vf_xfade.c.

◆ COVERV_TRANSITION

#define COVERV_TRANSITION ( dir,
name,
type,
div,
expr )
Value:
static void cover##dir##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = out->height; \
const int width = out->width; \
const int z = (expr progress) * height; \
\
for (int p = 0; p < s->nb_planes; p++) { \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const int zy = z + y; \
const int zz = zy % height + height * (zy < 0); \
const type *xf0 = (const type *)(a->data[p] + y * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + zz * b->linesize[p]); \
\
for (int x = 0; x < width; x++) \
dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
\
dst += out->linesize[p] / div; \
} \
} \
}

Definition at line 1903 of file vf_xfade.c.

◆ REVEALH_TRANSITION

#define REVEALH_TRANSITION ( dir,
name,
type,
div,
expr )
Value:
static void reveal##dir##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = slice_end - slice_start; \
const int width = out->width; \
const int z = (expr progress) * width; \
\
for (int p = 0; p < s->nb_planes; p++) { \
const type *xf0 = (const type *)(a->data[p] + slice_start * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + slice_start * b->linesize[p]); \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = 0; y < height; y++) { \
for (int x = 0; x < width; x++) { \
const int zx = z + x; \
const int zz = zx % width + width * (zx < 0); \
dst[x] = (zx >= 0) && (zx < width) ? xf1[x] : xf0[zz]; \
} \
\
dst += out->linesize[p] / div; \
xf0 += a->linesize[p] / div; \
xf1 += b->linesize[p] / div; \
} \
} \
}

Definition at line 1936 of file vf_xfade.c.

◆ REVEALV_TRANSITION

#define REVEALV_TRANSITION ( dir,
name,
type,
div,
expr )
Value:
static void reveal##dir##name##_transition(AVFilterContext *ctx, \
const AVFrame *a, const AVFrame *b, AVFrame *out, \
float progress, \
int slice_start, int slice_end, int jobnr) \
{ \
XFadeContext *s = ctx->priv; \
const int height = out->height; \
const int width = out->width; \
const int z = (expr progress) * height; \
\
for (int p = 0; p < s->nb_planes; p++) { \
type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
\
for (int y = slice_start; y < slice_end; y++) { \
const int zy = z + y; \
const int zz = zy % height + height * (zy < 0); \
const type *xf0 = (const type *)(a->data[p] + zz * a->linesize[p]); \
const type *xf1 = (const type *)(b->data[p] + y * b->linesize[p]); \
\
for (int x = 0; x < width; x++) \
dst[x] = (zy >= 0) && (zy < height) ? xf1[x] : xf0[x]; \
\
dst += out->linesize[p] / div; \
} \
} \
}

Definition at line 1971 of file vf_xfade.c.

Enumeration Type Documentation

◆ XFadeTransitions

enum XFadeTransitions
Enumerator
CUSTOM 
FADE 
WIPELEFT 
WIPERIGHT 
WIPEUP 
WIPEDOWN 
SLIDELEFT 
SLIDERIGHT 
SLIDEUP 
SLIDEDOWN 
CIRCLECROP 
RECTCROP 
DISTANCE 
FADEBLACK 
FADEWHITE 
RADIAL 
SMOOTHLEFT 
SMOOTHRIGHT 
SMOOTHUP 
SMOOTHDOWN 
CIRCLEOPEN 
CIRCLECLOSE 
VERTOPEN 
VERTCLOSE 
HORZOPEN 
HORZCLOSE 
DISSOLVE 
PIXELIZE 
DIAGTL 
DIAGTR 
DIAGBL 
DIAGBR 
HLSLICE 
HRSLICE 
VUSLICE 
VDSLICE 
HBLUR 
FADEGRAYS 
WIPETL 
WIPETR 
WIPEBL 
WIPEBR 
SQUEEZEH 
SQUEEZEV 
ZOOMIN 
FADEFAST 
FADESLOW 
HLWIND 
HRWIND 
VUWIND 
VDWIND 
COVERLEFT 
COVERRIGHT 
COVERUP 
COVERDOWN 
REVEALLEFT 
REVEALRIGHT 
REVEALUP 
REVEALDOWN 
NB_TRANSITIONS 

Definition at line 29 of file vf_xfade.c.

◆ anonymous enum

anonymous enum
Enumerator
VAR_X 
VAR_Y 
VAR_W 
VAR_H 
VAR_A 
VAR_B 
VAR_PLANE 
VAR_PROGRESS 
VAR_VARS_NB 

Definition at line 133 of file vf_xfade.c.

Function Documentation

◆ uninit()

static av_cold void uninit ( AVFilterContext * ctx)
static

Definition at line 160 of file vf_xfade.c.

◆ AVFILTER_DEFINE_CLASS()

AVFILTER_DEFINE_CLASS ( xfade )

◆ mix()

static float mix ( float a,
float b,
float mix )
inlinestatic

Definition at line 280 of file vf_xfade.c.

◆ fract()

static float fract ( float a)
inlinestatic

Definition at line 285 of file vf_xfade.c.

◆ smoothstep()

static float smoothstep ( float edge0,
float edge1,
float x )
inlinestatic

Definition at line 290 of file vf_xfade.c.

◆ frand()

static float frand ( int x,
int y )
static

Definition at line 1061 of file vf_xfade.c.

◆ zoom()

static void zoom ( float * u,
float * v,
float amount )
static

Definition at line 1695 of file vf_xfade.c.

Referenced by activate(), filter_frame(), output_single_frame(), and zoom().

◆ getpix()

static double getpix ( void * priv,
double x,
double y,
int plane,
int nb )
inlinestatic

Definition at line 2004 of file vf_xfade.c.

Referenced by a0(), a1(), a2(), a3(), b0(), b1(), b2(), and b3().

◆ a0()

static double a0 ( void * priv,
double x,
double y )
static

Definition at line 2028 of file vf_xfade.c.

Referenced by alf_classify(), av_reduce(), av_rescale_rnd(), biquad_process(), blackman(), cavs_idct8_add_c(), check_add_median_pred(), config_audio_input(), config_input(), config_output(), def_diag_downleft(), def_diag_downright(), def_hor_down(), def_vert_right(), diag_downleft_4x4_c(), ebur128_init_filter(), ff_h264_idct8_add(), ff_put_no_rnd_pixels_l2_msa(), ff_rfps_add_frame(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), filter_mbedge(), filter_mbedge(), idct4col_add(), idct4col_put(), idct4row(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), mc_block(), plot_channel_log(), predictor_decode_stereo_3950(), qmf_synth(), set_ap(), set_hp(), set_lp(), set_params(), set_params(), set_tf1s(), unpack_10bit(), vb_stereo(), vc1_filter_line(), vc1_filter_line(), wmv2_idct_col(), wmv2_idct_col_mmi(), wmv2_idct_row(), wmv2_idct_row_mmi(), yuv2rgb_full_2_template_lasx(), and yuv2rgb_full_2_template_lsx().

◆ a1()

static double a1 ( void * priv,
double x,
double y )
static

Definition at line 2029 of file vf_xfade.c.

Referenced by add_interval(), alf_classify(), av_adler32_update(), av_reduce(), av_rescale_rnd(), biquad_process(), biquad_process(), blackman(), block_angle(), cavs_idct8_add_c(), check_add_median_pred(), config_input(), config_output(), dct4x4(), decode_c82i(), decode_c82p(), decode_ca2i(), decode_ca2p(), decode_lpc(), decode_predictor_coeffs(), def_diag_downleft(), def_diag_downright(), def_hor_down(), def_vert_right(), dequant_lsp10r(), dequant_lsp16r(), diag_downleft_4x4_c(), ff_h264_idct8_add(), ff_put_no_rnd_pixels_l2_msa(), ff_rfps_add_frame(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), ff_vp8_luma_dc_wht_msa(), filter_channels(), filter_frame(), filter_mbedge(), filter_mbedge(), filter_samples(), filter_slice(), ibc_spatial_candidates(), idct4col_add(), idct4col_put(), idct4row(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), mc_block(), mode01(), mode02(), mode03(), mode04(), mode05(), mode06(), mode07(), mode08(), mode09(), mode10(), mode1112(), mode1314(), mode1516(), mode17(), mode18(), mode19(), mode20(), mode21(), mode22(), mode23(), mode24(), plot_channel_log(), predictor_decode_stereo_3950(), qmf_synth(), residue_encode(), sb_temporal_luma_motion_data(), sb_temporal_merge_candidate(), set_ap(), set_hp(), set_lp(), set_params(), set_params(), synth_superframe(), unpack_10bit(), vb_stereo(), vc1_filter_line(), vc1_filter_line(), wavesynth_parse_extradata(), wht4x4(), wmv2_idct_col(), wmv2_idct_col_mmi(), wmv2_idct_row(), wmv2_idct_row_mmi(), yuv2rgb_full_2_template_lasx(), and yuv2rgb_full_2_template_lsx().

◆ a2()

static double a2 ( void * priv,
double x,
double y )
static

Definition at line 2030 of file vf_xfade.c.

Referenced by add_interval(), av_adler32_update(), av_rescale_rnd(), biquad_process(), biquad_process(), blackman(), block_angle(), cavs_idct8_add_c(), compare_by_prob(), config_input(), config_output(), decode_block(), decode_c82i(), decode_c82p(), decode_ca2i(), decode_ca2p(), decode_lpc(), decode_predictor_coeffs(), def_diag_downleft(), def_diag_downright(), def_hor_down(), def_vert_right(), dequant_lsp10r(), dequant_lsp16r(), diag_downleft_4x4_c(), dv_guess_qnos(), ff_h264_idct8_add(), ff_put_no_rnd_pixels_l2_msa(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), filter_channels(), filter_frame(), filter_mbedge(), filter_mbedge(), filter_samples(), filter_slice(), idct4col_add(), idct4col_put(), idct4row(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), int_sin(), mc_block(), mode01(), mode02(), mode03(), mode04(), mode05(), mode06(), mode07(), mode08(), mode09(), mode10(), mode1112(), mode1314(), mode1516(), mode17(), mode18(), mode19(), mode20(), mode21(), mode22(), mode23(), mode24(), residue_encode(), set_ap(), set_hp(), set_lp(), set_params(), set_params(), synth_superframe(), unpack_10bit(), vb_stereo(), vc1_filter_line(), vc1_filter_line(), wavesynth_parse_extradata(), wmv2_idct_col(), wmv2_idct_col_mmi(), wmv2_idct_row(), and wmv2_idct_row_mmi().

◆ a3()

static double a3 ( void * priv,
double x,
double y )
static

Definition at line 2031 of file vf_xfade.c.

Referenced by cavs_idct8_add_c(), config_output(), decode_lpc(), def_diag_downleft(), def_diag_downright(), def_hor_down(), diag_downleft_4x4_c(), ff_h264_idct8_add(), ff_put_no_rnd_pixels_l2_msa(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), filter_slice(), idct4col_add(), idct4col_put(), idct4row(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), mc_block(), mode01(), mode02(), mode03(), mode04(), mode05(), mode06(), mode07(), mode08(), mode09(), mode10(), mode1112(), mode1314(), mode1516(), mode17(), mode18(), mode19(), mode20(), mode21(), mode22(), mode23(), mode24(), set_params(), unpack_10bit(), vc1_filter_line(), vc1_filter_line(), wmv2_idct_col(), wmv2_idct_col_mmi(), wmv2_idct_row(), and wmv2_idct_row_mmi().

◆ b0()

static double b0 ( void * priv,
double x,
double y )
static

Definition at line 2033 of file vf_xfade.c.

Referenced by alf_classify(), av_rescale_rnd(), biquad_process(), calc_lowcomp(), calc_lowcomp1(), cavs_idct8_add_c(), check_add_median_pred(), checkasm_check_synth_filter(), colorcontrast_slice16(), colorcontrast_slice16p(), colorcontrast_slice8(), colorcontrast_slice8p(), config_output(), extract_color(), ff_aac_apply_tns(), ff_add_pixels_clamped_lasx(), ff_h264_idct8_add(), ff_ivi_recompose_haar(), ff_put_no_rnd_pixels_l2_msa(), ff_put_pixels_clamped_lasx(), ff_put_signed_pixels_clamped_lasx(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), filter_channels(), filter_frame(), filter_horizontally(), filter_samples(), generate_noise(), horizontal_compose_daub97i_TMPL(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), kaiser_beta(), nmr_apply_is_band(), nmr_apply_ms_band(), nmr_decide_stereo(), nmr_solve(), set_ap(), set_highshelf_rbj(), set_hp(), set_lp(), set_params(), set_tf1s(), snow_vertical_compose97i(), spatial_compose53i_dy(), spatial_compose53i_dy_buffered(), spatial_compose97i_dy(), spatial_compose97i_dy_buffered(), spatial_compose_haari_dy_TMPL(), spatial_decompose53i(), spatial_decompose97i(), vb_stereo(), vertical_compose53iH0(), vertical_compose53iL0(), vertical_compose53iL0_TMPL(), vertical_compose97iH0(), vertical_compose97iH1(), vertical_compose97iL0(), vertical_compose97iL1(), vertical_compose_daub97iH0_TMPL(), vertical_compose_daub97iH1_TMPL(), vertical_compose_daub97iL0_TMPL(), vertical_compose_daub97iL1_TMPL(), vertical_compose_dd137iL0_TMPL(), vertical_compose_dd97iH0_TMPL(), vertical_compose_dirac53iH0_TMPL(), vertical_compose_fidelityiH0_TMPL(), vertical_compose_fidelityiL0_TMPL(), vertical_compose_haar_TMPL(), vertical_decompose53iH0(), vertical_decompose53iL0(), vertical_decompose97iH0(), vertical_decompose97iH1(), vertical_decompose97iL0(), vertical_decompose97iL1(), yuv2rgb_full_2_template_lasx(), and yuv2rgb_full_2_template_lsx().

◆ b1()

static double b1 ( void * priv,
double x,
double y )
static

Definition at line 2034 of file vf_xfade.c.

Referenced by alf_classify(), av_adler32_update(), av_rescale_rnd(), biquad_process(), biquad_process(), calc_lowcomp(), calc_lowcomp1(), cavs_idct8_add_c(), check_add_median_pred(), checkasm_check_synth_filter(), colorcontrast_slice16(), colorcontrast_slice16p(), colorcontrast_slice8(), colorcontrast_slice8p(), config_input(), config_output(), dct4x4(), decode_dlta(), decode_hq_slice(), decode_move(), decode_predictor_coeffs(), decode_subband(), extract_color(), ff_add_pixels_clamped_lasx(), ff_eval_coefs(), ff_h264_idct8_add(), ff_ivi_recompose_haar(), ff_put_no_rnd_pixels_l2_msa(), ff_put_pixels_clamped_lasx(), ff_put_signed_pixels_clamped_lasx(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), ff_vp8_luma_dc_wht_msa(), filter_channels(), filter_frame(), filter_horizontally(), filter_samples(), horizontal_compose_daub97i_TMPL(), ibc_spatial_candidates(), icc_context(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), kaiser_beta(), nmr_apply_is_band(), nmr_apply_ms_band(), nmr_decide_stereo(), parse_chunk_headers(), PUTBGR24(), PUTRGB(), PUTRGB24(), residue_encode(), rgb24_to_yuv420p(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_STORE(), RGB32_STORE_RES(), RGB_PACK(), RGB_PACK(), RGB_PACK(), RGB_STORE(), RGB_STORE_RES(), run_test(), search_for_ms(), set_ap(), set_hp(), set_lp(), set_params(), set_tf1s(), snow_vertical_compose97i(), spatial_compose53i_dy(), spatial_compose53i_dy_buffered(), spatial_compose97i_dy(), spatial_compose97i_dy_buffered(), spatial_compose_haari_dy_TMPL(), spatial_decompose53i(), spatial_decompose97i(), vb_stereo(), vc_generate(), vertical_compose53iH0(), vertical_compose53iL0(), vertical_compose53iL0_TMPL(), vertical_compose97iH0(), vertical_compose97iH1(), vertical_compose97iL0(), vertical_compose97iL1(), vertical_compose_daub97iH0_TMPL(), vertical_compose_daub97iH1_TMPL(), vertical_compose_daub97iL0_TMPL(), vertical_compose_daub97iL1_TMPL(), vertical_compose_dd137iL0_TMPL(), vertical_compose_dd97iH0_TMPL(), vertical_compose_dirac53iH0_TMPL(), vertical_compose_fidelityiH0_TMPL(), vertical_compose_fidelityiL0_TMPL(), vertical_compose_haar_TMPL(), vertical_decompose53iH0(), vertical_decompose53iL0(), vertical_decompose97iH0(), vertical_decompose97iH1(), vertical_decompose97iL0(), vertical_decompose97iL1(), wht4x4(), YUV2RGB(), YUV2RGB(), yuv2rgb_full_2_template_lasx(), and yuv2rgb_full_2_template_lsx().

◆ b2()

static double b2 ( void * priv,
double x,
double y )
static

Definition at line 2035 of file vf_xfade.c.

Referenced by av_adler32_update(), biquad_process(), biquad_process(), cavs_idct8_add_c(), colorcontrast_slice16(), colorcontrast_slice16p(), colorcontrast_slice8(), colorcontrast_slice8p(), compare_by_prob(), config_input(), config_output(), decode_dlta(), decode_move(), decode_predictor_coeffs(), decode_subband(), ff_add_pixels_clamped_lasx(), ff_eval_coefs(), ff_h264_idct8_add(), ff_ivi_recompose_haar(), ff_put_no_rnd_pixels_l2_msa(), ff_put_pixels_clamped_lasx(), ff_put_signed_pixels_clamped_lasx(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), filter_channels(), filter_frame(), filter_samples(), horizontal_compose_daub97i_TMPL(), icc_context(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), parse_chunk_headers(), PUTBGR24(), PUTRGB(), PUTRGB24(), qoi_decode_frame(), qpel_motion_search(), residue_encode(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_PACK(), RGB32_STORE(), RGB_PACK(), RGB_PACK(), run_test(), search_for_ms(), set_ap(), set_hp(), set_lp(), set_params(), snow_vertical_compose97i(), spatial_compose53i_dy(), spatial_compose53i_dy_buffered(), spatial_compose97i_dy(), spatial_compose97i_dy_buffered(), spatial_decompose53i(), spatial_decompose97i(), vertical_compose53iH0(), vertical_compose53iL0(), vertical_compose53iL0_TMPL(), vertical_compose97iH0(), vertical_compose97iH1(), vertical_compose97iL0(), vertical_compose97iL1(), vertical_compose_daub97iH0_TMPL(), vertical_compose_daub97iH1_TMPL(), vertical_compose_daub97iL0_TMPL(), vertical_compose_daub97iL1_TMPL(), vertical_compose_dd137iL0_TMPL(), vertical_compose_dd97iH0_TMPL(), vertical_compose_dirac53iH0_TMPL(), vertical_compose_fidelityiH0_TMPL(), vertical_compose_fidelityiL0_TMPL(), vertical_decompose53iH0(), vertical_decompose53iL0(), vertical_decompose97iH0(), vertical_decompose97iH1(), vertical_decompose97iL0(), vertical_decompose97iL1(), YUV2RGB(), and YUV2RGB().

◆ b3()

static double b3 ( void * priv,
double x,
double y )
static

Definition at line 2036 of file vf_xfade.c.

Referenced by cavs_idct8_add_c(), config_output(), ff_add_pixels_clamped_lasx(), ff_h264_idct8_add(), ff_ivi_recompose_haar(), ff_put_no_rnd_pixels_l2_msa(), ff_put_pixels_clamped_lasx(), ff_put_signed_pixels_clamped_lasx(), ff_simple_idct_add_lasx(), ff_simple_idct_lasx(), ff_simple_idct_put_lasx(), idct_row(), idctRowCondDC(), idctSparseCol(), idctSparseColAdd(), idctSparseColPut(), randomize_luma_buffers(), search_for_ms(), snow_vertical_compose97i(), spatial_compose53i_dy(), spatial_compose53i_dy_buffered(), spatial_compose97i_dy(), spatial_compose97i_dy_buffered(), spatial_decompose53i(), spatial_decompose97i(), vertical_compose_dd137iL0_TMPL(), vertical_compose_dd97iH0_TMPL(), vertical_compose_fidelityiH0_TMPL(), and vertical_compose_fidelityiL0_TMPL().

◆ config_output()

static int config_output ( AVFilterLink * outlink)
static

Definition at line 2038 of file vf_xfade.c.

◆ xfade_slice()

static int xfade_slice ( AVFilterContext * ctx,
void * arg,
int jobnr,
int nb_jobs )
static

Definition at line 2191 of file vf_xfade.c.

Referenced by xfade_frame().

◆ xfade_frame()

static int xfade_frame ( AVFilterContext * ctx,
AVFrame * a,
AVFrame * b )
static

Definition at line 2204 of file vf_xfade.c.

Referenced by xfade_activate().

◆ forward_frame()

static int forward_frame ( XFadeContext * s,
AVFilterLink * inlink,
AVFilterLink * outlink )
static

Definition at line 2226 of file vf_xfade.c.

Referenced by xfade_activate().

◆ xfade_activate()

static int xfade_activate ( AVFilterContext * avctx)
static

Definition at line 2264 of file vf_xfade.c.

◆ get_video_buffer()

static AVFrame * get_video_buffer ( AVFilterLink * inlink,
int w,
int h )
static

Definition at line 2363 of file vf_xfade.c.

Variable Documentation

◆ var_names

const char* const var_names[] = { "X", "Y", "W", "H", "A", "B", "PLANE", "P", NULL }
static

Definition at line 132 of file vf_xfade.c.

◆ pix_fmts

enum AVPixelFormat pix_fmts[]
static
Initial value:
= {
AV_PIX_FMT_YUVA444P,
AV_PIX_FMT_YUVJ444P,
AV_PIX_FMT_YUV444P,
AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8,
AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_GBRP9,
AV_PIX_FMT_YUV444P10,
AV_PIX_FMT_YUVA444P10,
AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GRAY10,
AV_PIX_FMT_YUV444P12,
AV_PIX_FMT_YUVA444P12,
AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GRAY12,
AV_PIX_FMT_YUV444P14, AV_PIX_FMT_GBRP14,
AV_PIX_FMT_YUV444P16,
AV_PIX_FMT_YUVA444P16,
AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GRAY16,
AV_PIX_FMT_NONE
}
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition pixfmt.h:569
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition pixfmt.h:552
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition pixfmt.h:571
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition pixfmt.h:563
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition pixfmt.h:598
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition pixfmt.h:564
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition pixfmt.h:526
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition pixfmt.h:565
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition pixfmt.h:78
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition pixfmt.h:174
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition pixfmt.h:212
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition pixfmt.h:165
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition pixfmt.h:87
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition pixfmt.h:525
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition pixfmt.h:528
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition pixfmt.h:568
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition pixfmt.h:603
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition pixfmt.h:567
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition pixfmt.h:555
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition pixfmt.h:595
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition pixfmt.h:566
AV_PIX_FMT_YUVA444P12
#define AV_PIX_FMT_YUVA444P12
Definition pixfmt.h:600
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition pixfmt.h:558
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition pixfmt.h:548

Definition at line 141 of file vf_xfade.c.

◆ xfade_options

const AVOption xfade_options[]
static

Definition at line 170 of file vf_xfade.c.

◆ xfade_inputs

const AVFilterPad xfade_inputs[]
static
Initial value:
= {
{
.name = "main",
.type = AVMEDIA_TYPE_VIDEO,
.get_buffer.video = get_video_buffer,
},
{
.name = "xfade",
.type = AVMEDIA_TYPE_VIDEO,
.get_buffer.video = get_video_buffer,
},
}
get_video_buffer
static AVFrame * get_video_buffer(AVFilterLink *inlink, int w, int h)
Definition avf_concat.c:205
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200

Definition at line 2372 of file vf_xfade.c.

◆ xfade_outputs

const AVFilterPad xfade_outputs[]
static
Initial value:
= {
{
.name = "default",
.type = AVMEDIA_TYPE_VIDEO,
.config_props = config_output,
},
}
config_output
static int config_output(AVBitStreamFilterLink *outlink)
Definition lcevc_merge.c:111

Definition at line 2385 of file vf_xfade.c.

◆ ff_vf_xfade

const FFFilter ff_vf_xfade
Initial value:
= {
.p.name = "xfade",
.p.description = NULL_IF_CONFIG_SMALL("Cross fade one video with another video."),
.p.priv_class = &xfade_class,
.p.flags = AVFILTER_FLAG_SLICE_THREADS,
.priv_size = sizeof(XFadeContext),
.activate = xfade_activate,
.uninit = uninit,
FILTER_INPUTS(xfade_inputs),
FILTER_OUTPUTS(xfade_outputs),
FILTER_PIXFMTS_ARRAY(pix_fmts),
}
AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition avfilter.h:166
uninit
static av_cold void uninit(AVBitStreamFilterContext *ctx)
Definition lcevc_merge.c:135
activate
static int activate(AVBitStreamFilterContext *ctx)
Definition lcevc_merge.c:144
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition filters.h:264
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition filters.h:265
FILTER_PIXFMTS_ARRAY
#define FILTER_PIXFMTS_ARRAY(array)
Definition filters.h:244
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition internal.h:88
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition libkvazaar.c:296
xfade_activate
static int xfade_activate(AVFilterContext *avctx)
Definition vf_xfade.c:2264
xfade_inputs
static const AVFilterPad xfade_inputs[]
Definition vf_xfade.c:2372
xfade_outputs
static const AVFilterPad xfade_outputs[]
Definition vf_xfade.c:2385

Definition at line 2393 of file vf_xfade.c.

Generated on Sun Aug 16 2026 20:21:12 for FFmpeg by doxygen 1.13.2