FFmpeg
Data Structures | Macros | Enumerations | Functions | Variables
vf_xfade.c File Reference
#include "libavutil/imgutils.h"
#include "libavutil/eval.h"
#include "libavutil/opt.h"
#include "libavutil/pixfmt.h"
#include "avfilter.h"
#include "formats.h"
#include "internal.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)   offsetof(XFadeContext, 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)
 

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, NB_TRANSITIONS, CUSTOM,
  FADE, WIPELEFT, WIPERIGHT, WIPEUP,
  WIPEDOWN, SLIDELEFT, SLIDERIGHT, SLIDEUP,
  SLIDEDOWN, NB_TRANSITIONS
}
 
enum  {
  VAR_X, VAR_Y, VAR_W, VAR_H,
  VAR_A, VAR_B, VAR_PLANE, VAR_PROGRESS,
  VAR_VARS_NB
}
 

Functions

static int query_formats (AVFilterContext *ctx)
 
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 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 xfade_activate (AVFilterContext *ctx)
 

Variables

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

Macro Definition Documentation

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

Definition at line 151 of file vf_xfade.c.

Definition at line 152 of file vf_xfade.c.

#define CUSTOM_TRANSITION (   name,
  type,
  div 
)

Definition at line 206 of file vf_xfade.c.

#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; \
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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
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:491
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 265 of file vf_xfade.c.

#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 z = out->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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 294 of file vf_xfade.c.

#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 z = out->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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 324 of file vf_xfade.c.

#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 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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 354 of file vf_xfade.c.

#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 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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 384 of file vf_xfade.c.

#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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 414 of file vf_xfade.c.

#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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 447 of file vf_xfade.c.

#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 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 < out->width; x++) { \
dst[x] = (zy > 0) && (zy < height) ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 480 of file vf_xfade.c.

#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 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 < out->width; x++) { \
dst[x] = (zy > 0) && (zy < height) ? xf1[x] : xf0[x]; \
} \
\
dst += out->linesize[p] / div; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 511 of file vf_xfade.c.

#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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
#define powf(x, y)
Definition: libm.h:50
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
int
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
static double val(void *priv, double ch)
Definition: aeval.c:76
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 542 of file vf_xfade.c.

#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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
static double val(void *priv, double ch)
Definition: aeval.c:76
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 575 of file vf_xfade.c.

#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); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define max(a, b)
Definition: cuda_runtime.h:33
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
static float distance(float x, float y, int band)
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 610 of file vf_xfade.c.

#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 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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 645 of file vf_xfade.c.

#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 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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 678 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
#define atan2f(y, x)
Definition: libm.h:45
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
#define M_PI
Definition: mathematics.h:52
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 711 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 739 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 767 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 795 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 822 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 849 of file vf_xfade.c.

#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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
#define height
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 878 of file vf_xfade.c.

#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; \
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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 907 of file vf_xfade.c.

#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 width = out->width; \
const float w2 = out->width / 2; \
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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 934 of file vf_xfade.c.

#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 width = out->width; \
const float h2 = out->height / 2; \
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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 961 of file vf_xfade.c.

#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 width = out->width; \
const float h2 = out->height / 2; \
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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 988 of file vf_xfade.c.

#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 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 < 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] = smooth >= 0.5f ? xf0[x] : xf1[x]; \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float frand(int x, int y)
Definition: vf_xfade.c:1015
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1022 of file vf_xfade.c.

#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 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 < s->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); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
float fminf(float, float)
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
int
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1048 of file vf_xfade.c.

#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 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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1080 of file vf_xfade.c.

#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 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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1109 of file vf_xfade.c.

#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 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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1138 of file vf_xfade.c.

#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 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 < 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)); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1167 of file vf_xfade.c.

#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 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 < 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], ss); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float fract(float a)
Definition: vf_xfade.c:251
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1197 of file vf_xfade.c.

#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 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 < 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], ss); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define b
Definition: input.c:41
#define width
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float fract(float a)
Definition: vf_xfade.c:251
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1226 of file vf_xfade.c.

#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 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 < 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], ss); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float fract(float a)
Definition: vf_xfade.c:251
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1256 of file vf_xfade.c.

#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 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 < 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], ss); \
} \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define f(width, name)
Definition: cbs_vp9.c:255
static float mix(float a, float b, float mix)
Definition: vf_xfade.c:246
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
#define b
Definition: input.c:41
#define width
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static float fract(float a)
Definition: vf_xfade.c:251
static float smooth(DeshakeOpenCLContext *deshake_ctx, float *gauss_kernel, int length, float max_val, AVFifoBuffer *values)
static float smoothstep(float edge0, float edge1, float x)
Definition: vf_xfade.c:256
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1285 of file vf_xfade.c.

#define HBLUR_TRANSITION (   name,
  type,
  div 
)

Definition at line 1315 of file vf_xfade.c.

#define FADEGRAYS_TRANSITION (   name,
  type,
  div 
)

Definition at line 1359 of file vf_xfade.c.

#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 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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1428 of file vf_xfade.c.

#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 zw = out->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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1460 of file vf_xfade.c.

#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 zw = out->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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1492 of file vf_xfade.c.

#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 zw = out->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 < out->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; \
} \
} \
}
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
#define height
#define b
Definition: input.c:41
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2035
An instance of a filter.
Definition: avfilter.h:341
FILE * out
Definition: movenc.c:54
for(j=16;j >0;--j)
const char * name
Definition: opengl_enc.c:102

Definition at line 1524 of file vf_xfade.c.

Enumeration Type Documentation

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 
NB_TRANSITIONS 
CUSTOM 
FADE 
WIPELEFT 
WIPERIGHT 
WIPEUP 
WIPEDOWN 
SLIDELEFT 
SLIDERIGHT 
SLIDEUP 
SLIDEDOWN 
NB_TRANSITIONS 

Definition at line 31 of file vf_xfade.c.

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 109 of file vf_xfade.c.

Function Documentation

static int query_formats ( AVFilterContext ctx)
static

Definition at line 117 of file vf_xfade.c.

static av_cold void uninit ( AVFilterContext ctx)
static

Definition at line 144 of file vf_xfade.c.

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

Definition at line 246 of file vf_xfade.c.

static float fract ( float  a)
inlinestatic

Definition at line 251 of file vf_xfade.c.

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

Definition at line 256 of file vf_xfade.c.

static float frand ( int  x,
int  y 
)
static

Definition at line 1015 of file vf_xfade.c.

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

Definition at line 1556 of file vf_xfade.c.

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

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

Definition at line 1580 of file vf_xfade.c.

Referenced by config_output().

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

Definition at line 1581 of file vf_xfade.c.

Referenced by config_output().

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

Definition at line 1582 of file vf_xfade.c.

Referenced by config_output().

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

Definition at line 1583 of file vf_xfade.c.

Referenced by config_output().

static double b0 ( void priv,
double  x,
double  y 
)
static
static double b1 ( void priv,
double  x,
double  y 
)
static
static double b2 ( void priv,
double  x,
double  y 
)
static
static double b3 ( void priv,
double  x,
double  y 
)
static
static int config_output ( AVFilterLink outlink)
static

Definition at line 1590 of file vf_xfade.c.

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

Definition at line 1728 of file vf_xfade.c.

Referenced by xfade_frame().

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

Definition at line 1741 of file vf_xfade.c.

Referenced by xfade_activate().

static int xfade_activate ( AVFilterContext ctx)
static

Definition at line 1761 of file vf_xfade.c.

Variable Documentation

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

Definition at line 108 of file vf_xfade.c.

Referenced by config_output().

const AVOption xfade_options[]
static

Definition at line 154 of file vf_xfade.c.

const AVFilterPad xfade_inputs[]
static
Initial value:
= {
{
.name = "main",
},
{
.name = "xfade",
},
{ NULL }
}
#define NULL
Definition: coverity.c:32

Definition at line 1851 of file vf_xfade.c.

const AVFilterPad xfade_outputs[]
static
Initial value:
= {
{
.name = "default",
.config_props = config_output,
},
{ NULL }
}
#define NULL
Definition: coverity.c:32
static int config_output(AVFilterLink *outlink)
Definition: vf_xfade.c:1590

Definition at line 1863 of file vf_xfade.c.

AVFilter ff_vf_xfade
Initial value:
= {
.name = "xfade",
.description = NULL_IF_CONFIG_SMALL("Cross fade one video with another video."),
.priv_size = sizeof(XFadeContext),
.priv_class = &xfade_class,
}
static int query_formats(AVFilterContext *ctx)
Definition: vf_xfade.c:117
static int xfade_activate(AVFilterContext *ctx)
Definition: vf_xfade.c:1761
filter_frame For filters that do not use the activate() callback
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_xfade.c:144
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:117
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static const AVFilterPad xfade_inputs[]
Definition: vf_xfade.c:1851
static const AVFilterPad xfade_outputs[]
Definition: vf_xfade.c:1863

Definition at line 1872 of file vf_xfade.c.