vf_overlay.c File Reference

#include "avfilter.h"
#include "formats.h"
#include "libavutil/common.h"
#include "libavutil/eval.h"
#include "libavutil/avstring.h"
#include "libavutil/pixdesc.h"
#include "libavutil/imgutils.h"
#include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "libavutil/timestamp.h"
#include "filters.h"
#include "drawutils.h"
#include "framesync.h"
#include "video.h"
#include "vf_overlay.h"

Go to the source code of this file.

Data Structures
struct	ThreadData
	Used for passing data between threads. More...

Macros
#define	MAIN   0
#define	OVERLAY   1
#define	R   0
#define	G   1
#define	B   2
#define	A   3
#define	Y   0
#define	U   1
#define	V   2
#define	FAST_DIV255(x)   ((((x) + 128) * 257) >> 16)
#define	UNPREMULTIPLY_ALPHA(x, y)   ((((x) << 16) - ((x) << 9) + (x)) / ((((x) + (y)) << 8) - ((x) + (y)) - (y) * (x)))
#define	DEFINE_BLEND_PLANE(depth, nbits)
#define	DEFINE_ALPHA_COMPOSITE(depth, nbits)
#define	DEFINE_BLEND_SLICE_YUV(depth, nbits)
#define	DEFINE_BLEND_SLICE_PLANAR_FMT(format_, blend_slice_fn_suffix_, hsub_, vsub_, main_has_alpha_, direct_)
#define	DEFINE_BLEND_SLICE_PACKED_FMT(format_, blend_slice_fn_suffix_, main_has_alpha_, direct_)
#define	OFFSET(x)   offsetof(OverlayContext, x)
#define	FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
#define	TFLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

Enumerations
enum	EvalMode {   EVAL_MODE_ONCE, EVAL_MODE_FRAME, EVAL_MODE_NB, EVAL_MODE_INIT,   EVAL_MODE_FRAME, EVAL_MODE_NB, EVAL_MODE_INIT, EVAL_MODE_FRAME,   EVAL_MODE_NB, EVAL_MODE_INIT, EVAL_MODE_FRAME, EVAL_MODE_NB,   EVAL_MODE_INIT, EVAL_MODE_FRAME, EVAL_MODE_NB, EVAL_MODE_INIT,   EVAL_MODE_FRAME, EVAL_MODE_NB, EVAL_MODE_INIT, EVAL_MODE_FRAME,   EVAL_MODE_NB, EVAL_MODE_INIT, EVAL_MODE_FRAME, EVAL_MODE_NB,   EVAL_MODE_INIT, EVAL_MODE_FRAME, EVAL_MODE_NB }

Functions
static av_cold void	uninit (AVFilterContext *ctx)
static int	normalize_xy (double d, int chroma_sub)
static void	eval_expr (AVFilterContext *ctx)
static int	set_expr (AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
static int	process_command (AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
static int	query_formats (const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
static int	config_input_overlay (AVFilterLink *inlink)
static int	config_output (AVFilterLink *outlink)
static av_always_inline void	blend_slice_packed_rgb (AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int main_has_alpha, int x, int y, int is_straight, int jobnr, int nb_jobs)
	Blend image in src to destination buffer dst at position (x, y). More...
static av_always_inline void	blend_slice_planar_rgb (AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int hsub, int vsub, int main_has_alpha, int x, int y, int is_straight, int jobnr, int nb_jobs)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv420, yuv_8_8bits, 1, 1, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva420, yuv_8_8bits, 1, 1, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv420p10, yuv_16_10bits, 1, 1, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva420p10, yuv_16_10bits, 1, 1, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv422p10, yuv_16_10bits, 1, 0, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva422p10, yuv_16_10bits, 1, 0, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv422, yuv_8_8bits, 1, 0, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva422, yuv_8_8bits, 1, 0, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv444, yuv_8_8bits, 0, 0, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva444, yuv_8_8bits, 0, 0, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv444p10, yuv_16_10bits, 0, 0, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva444p10, yuv_16_10bits, 0, 0, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (gbrp, planar_rgb, 0, 0, 0, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (gbrap, planar_rgb, 0, 0, 1, 1)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv420_pm, yuv_8_8bits, 1, 1, 0, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva420_pm, yuv_8_8bits, 1, 1, 1, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv422_pm, yuv_8_8bits, 1, 0, 0, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva422_pm, yuv_8_8bits, 1, 0, 1, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuv444_pm, yuv_8_8bits, 0, 0, 0, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (yuva444_pm, yuv_8_8bits, 0, 0, 1, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (gbrp_pm, planar_rgb, 0, 0, 0, 0)
	DEFINE_BLEND_SLICE_PLANAR_FMT (gbrap_pm, planar_rgb, 0, 0, 1, 0)
	DEFINE_BLEND_SLICE_PACKED_FMT (rgb, rgb, 0, 1)
	DEFINE_BLEND_SLICE_PACKED_FMT (rgba, rgb, 1, 1)
	DEFINE_BLEND_SLICE_PACKED_FMT (rgb_pm, rgb, 0, 0)
	DEFINE_BLEND_SLICE_PACKED_FMT (rgba_pm, rgb, 1, 0)
static int	config_input_main (AVFilterLink *inlink)
static int	do_blend (FFFrameSync *fs)
static av_cold int	init (AVFilterContext *ctx)
static int	activate (AVFilterContext *ctx)
	FRAMESYNC_DEFINE_CLASS (overlay, OverlayContext, fs)

Variables
static const char *const	var_names []
static enum AVPixelFormat	alpha_pix_fmts []
static const AVOption	overlay_options []
static const AVFilterPad	avfilter_vf_overlay_inputs []
static const AVFilterPad	avfilter_vf_overlay_outputs []
const AVFilter	ff_vf_overlay

Detailed Description

overlay one video on top of another

Definition in file vf_overlay.c.

Macro Definition Documentation

MAIN

#define MAIN   0

Definition at line 65 of file vf_overlay.c.

OVERLAY

#define OVERLAY   1

Definition at line 66 of file vf_overlay.c.

R

#define R   0

Definition at line 68 of file vf_overlay.c.

G

#define G   1

Definition at line 69 of file vf_overlay.c.

B

#define B   2

Definition at line 70 of file vf_overlay.c.

A

#define A   3

Definition at line 71 of file vf_overlay.c.

Y

#define Y   0

Definition at line 73 of file vf_overlay.c.

U

#define U   1

Definition at line 74 of file vf_overlay.c.

V

#define V   2

Definition at line 75 of file vf_overlay.c.

FAST_DIV255

#define FAST_DIV255

(

x

)

((((x) + 128) * 257) >> 16)

Definition at line 354 of file vf_overlay.c.

UNPREMULTIPLY_ALPHA

#define UNPREMULTIPLY_ALPHA	(		x,
			y
	)		((((x) << 16) - ((x) << 9) + (x)) / ((((x) + (y)) << 8) - ((x) + (y)) - (y) * (x)))

Definition at line 360 of file vf_overlay.c.

DEFINE_BLEND_PLANE

#define DEFINE_BLEND_PLANE	(		depth,
			nbits
	)

Definition at line 453 of file vf_overlay.c.

DEFINE_ALPHA_COMPOSITE

#define DEFINE_ALPHA_COMPOSITE	(		depth,
			nbits
	)

Definition at line 581 of file vf_overlay.c.

DEFINE_BLEND_SLICE_YUV

#define DEFINE_BLEND_SLICE_YUV	(		depth,
			nbits
	)

Value:

static av_always_inline void blend_slice_yuv_##depth##_##nbits##bits(AVFilterContext *ctx,                 \
                                             AVFrame *dst, const AVFrame *src,                             \
                                             int hsub, int vsub,                                           \
                                             int main_has_alpha,                                           \
                                             int x, int y,                                                 \
                                             int is_straight,                                              \
                                             int jobnr, int nb_jobs)                                       \
{                                                                                                          \
    OverlayContext *s = ctx->priv;                                                                         \
    const int src_w = src->width;                                                                          \
    const int src_h = src->height;                                                                         \
    const int dst_w = dst->width;                                                                          \
    const int dst_h = dst->height;                                                                         \
                                                                                                           \
    blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0,       0,          \
                x, y, main_has_alpha, s->main_desc->comp[0].plane, s->main_desc->comp[0].offset,           \
                s->main_desc->comp[0].step, is_straight, 1, jobnr, nb_jobs);                               \
    blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub,          \
                x, y, main_has_alpha, s->main_desc->comp[1].plane, s->main_desc->comp[1].offset,           \
                s->main_desc->comp[1].step, is_straight, 1, jobnr, nb_jobs);                               \
    blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub,          \
                x, y, main_has_alpha, s->main_desc->comp[2].plane, s->main_desc->comp[2].offset,           \
                s->main_desc->comp[2].step, is_straight, 1, jobnr, nb_jobs);                               \
                                                                                                           \
    if (main_has_alpha)                                                                                    \
        alpha_composite_##depth##_##nbits##bits(src, dst, src_w, src_h, dst_w, dst_h, x, y,                \
                                                jobnr, nb_jobs);                                           \
}

Definition at line 634 of file vf_overlay.c.

DEFINE_BLEND_SLICE_PLANAR_FMT

#define DEFINE_BLEND_SLICE_PLANAR_FMT	(		format_,
			blend_slice_fn_suffix_,
			hsub_,
			vsub_,
			main_has_alpha_,
			direct_
	)

Value:

static int blend_slice_##format_(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)           \
{                                                                       \
    OverlayContext *s = ctx->priv;                                      \
    ThreadData *td = arg;                                               \
    blend_slice_##blend_slice_fn_suffix_(ctx, td->dst, td->src,         \
                                         hsub_, vsub_, main_has_alpha_, \
                                         s->x, s->y, direct_,           \
                                         jobnr, nb_jobs);               \
    return 0;                                                           \
}

Definition at line 695 of file vf_overlay.c.

DEFINE_BLEND_SLICE_PACKED_FMT

#define DEFINE_BLEND_SLICE_PACKED_FMT	(		format_,
			blend_slice_fn_suffix_,
			main_has_alpha_,
			direct_
	)

Value:

static int blend_slice_##format_(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)        \
{                                                                       \
    OverlayContext *s = ctx->priv;                                      \
    ThreadData *td = arg;                                               \
    blend_slice_packed_##blend_slice_fn_suffix_(ctx, td->dst, td->src,  \
                                                main_has_alpha_,        \
                                                s->x, s->y, direct_,    \
                                                jobnr, nb_jobs);        \
    return 0;                                                           \
}

Definition at line 731 of file vf_overlay.c.

OFFSET

#define OFFSET

(

x

)

offsetof(OverlayContext, x)

Definition at line 947 of file vf_overlay.c.

FLAGS

#define FLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

Definition at line 948 of file vf_overlay.c.

TFLAGS

#define TFLAGS   AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

Definition at line 949 of file vf_overlay.c.

Enumeration Type Documentation

EvalMode

enum EvalMode

Enumerator
EVAL_MODE_ONCE
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB
EVAL_MODE_INIT
EVAL_MODE_FRAME
EVAL_MODE_NB

Definition at line 77 of file vf_overlay.c.

Function Documentation

uninit()

static av_cold void uninit ( AVFilterContext *  ctx )

static

Definition at line 83 of file vf_overlay.c.

normalize_xy()

static int normalize_xy ( double  d, int  chroma_sub  )

inlinestatic

Definition at line 92 of file vf_overlay.c.

Referenced by eval_expr().

eval_expr()

static void eval_expr ( AVFilterContext *  ctx )

static

Definition at line 99 of file vf_overlay.c.

Referenced by config_input_overlay(), do_blend(), and process_command().

set_expr()

static int set_expr ( AVExpr **  pexpr, const char *  expr, const char *  option, void *  log_ctx  )

static

Definition at line 111 of file vf_overlay.c.

Referenced by config_input_overlay(), and process_command().

process_command()

static int process_command ( AVFilterContext *  ctx, const char *  cmd, const char *  args, char *  res, int  res_len, int  flags  )

static

Definition at line 132 of file vf_overlay.c.

query_formats()

static int query_formats ( const AVFilterContext *  ctx, AVFilterFormatsConfig **  cfg_in, AVFilterFormatsConfig **  cfg_out  )

static

Definition at line 164 of file vf_overlay.c.

config_input_overlay()

static int config_input_overlay ( AVFilterLink *  inlink )

static

Definition at line 287 of file vf_overlay.c.

config_output()

static int config_output ( AVFilterLink *  outlink )

static

Definition at line 336 of file vf_overlay.c.

blend_slice_packed_rgb()

static av_always_inline void blend_slice_packed_rgb ( AVFilterContext *  ctx, AVFrame *  dst, const AVFrame *  src, int  main_has_alpha, int  x, int  y, int  is_straight, int  jobnr, int  nb_jobs  )

static

Blend image in src to destination buffer dst at position (x, y).

< the amount of overlay to blend on to main

Definition at line 366 of file vf_overlay.c.

blend_slice_planar_rgb()

static av_always_inline void blend_slice_planar_rgb ( AVFilterContext *  ctx, AVFrame *  dst, const AVFrame *  src, int  hsub, int  vsub, int  main_has_alpha, int  x, int  y, int  is_straight, int  jobnr, int  nb_jobs  )

static

Definition at line 666 of file vf_overlay.c.

DEFINE_BLEND_SLICE_PLANAR_FMT() [1/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv420	,
		yuv_8_8bits	,
		1	,
		1	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [2/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva420	,
		yuv_8_8bits	,
		1	,
		1	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [3/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv420p10	,
		yuv_16_10bits	,
		1	,
		1	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [4/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva420p10	,
		yuv_16_10bits	,
		1	,
		1	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [5/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv422p10	,
		yuv_16_10bits	,
		1	,
		0	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [6/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva422p10	,
		yuv_16_10bits	,
		1	,
		0	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [7/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv422	,
		yuv_8_8bits	,
		1	,
		0	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [8/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva422	,
		yuv_8_8bits	,
		1	,
		0	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [9/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv444	,
		yuv_8_8bits	,
		0	,
		0	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [10/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva444	,
		yuv_8_8bits	,
		0	,
		0	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [11/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv444p10	,
		yuv_16_10bits	,
		0	,
		0	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [12/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva444p10	,
		yuv_16_10bits	,
		0	,
		0	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [13/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	gbrp	,
		planar_rgb	,
		0	,
		0	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [14/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	gbrap	,
		planar_rgb	,
		0	,
		0	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [15/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv420_pm	,
		yuv_8_8bits	,
		1	,
		1	,
		0	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [16/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva420_pm	,
		yuv_8_8bits	,
		1	,
		1	,
		1	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [17/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv422_pm	,
		yuv_8_8bits	,
		1	,
		0	,
		0	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [18/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva422_pm	,
		yuv_8_8bits	,
		1	,
		0	,
		1	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [19/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuv444_pm	,
		yuv_8_8bits	,
		0	,
		0	,
		0	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [20/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	yuva444_pm	,
		yuv_8_8bits	,
		0	,
		0	,
		1	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [21/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	gbrp_pm	,
		planar_rgb	,
		0	,
		0	,
		0	,
		0
	)

DEFINE_BLEND_SLICE_PLANAR_FMT() [22/22]

DEFINE_BLEND_SLICE_PLANAR_FMT	(	gbrap_pm	,
		planar_rgb	,
		0	,
		0	,
		1	,
		0
	)

DEFINE_BLEND_SLICE_PACKED_FMT() [1/4]

DEFINE_BLEND_SLICE_PACKED_FMT	(	rgb	,
		rgb	,
		0	,
		1
	)

DEFINE_BLEND_SLICE_PACKED_FMT() [2/4]

DEFINE_BLEND_SLICE_PACKED_FMT	(	rgba	,
		rgb	,
		1	,
		1
	)

DEFINE_BLEND_SLICE_PACKED_FMT() [3/4]

DEFINE_BLEND_SLICE_PACKED_FMT	(	rgb_pm	,
		rgb	,
		0	,
		0
	)

DEFINE_BLEND_SLICE_PACKED_FMT() [4/4]

DEFINE_BLEND_SLICE_PACKED_FMT	(	rgba_pm	,
		rgb	,
		1	,
		0
	)

config_input_main()

static int config_input_main ( AVFilterLink *  inlink )

static

Definition at line 749 of file vf_overlay.c.

do_blend()

static int do_blend ( FFFrameSync *  fs )

static

Definition at line 880 of file vf_overlay.c.

Referenced by init().

init()

static av_cold int init ( AVFilterContext *  ctx )

static

Definition at line 933 of file vf_overlay.c.

activate()

static int activate ( AVFilterContext *  ctx )

static

Definition at line 941 of file vf_overlay.c.

FRAMESYNC_DEFINE_CLASS()

FRAMESYNC_DEFINE_CLASS	(	overlay	,
		OverlayContext	,
		fs
	)

Variable Documentation

var_names

const char* const var_names[]

static

Initial value:

= {
    "main_w",    "W", 
    "main_h",    "H", 
    "overlay_w", "w", 
    "overlay_h", "h", 
    "hsub",
    "vsub",
    "x",
    "y",
    "n",            
 
 
 
    "t",            
    NULL
}

Definition at line 48 of file vf_overlay.c.

Referenced by set_expr().

alpha_pix_fmts

enum AVPixelFormat alpha_pix_fmts[]

static

Initial value:

= {
    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
    AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
    AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA,
    AV_PIX_FMT_BGRA, AV_PIX_FMT_GBRAP, AV_PIX_FMT_NONE
}

Definition at line 157 of file vf_overlay.c.

Referenced by config_input_main(), config_input_overlay(), and query_formats().

overlay_options

const AVOption overlay_options[]

static

Initial value:

= {
    { "x", "set the x expression", OFFSET(x_expr), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, TFLAGS },
    { "y", "set the y expression", OFFSET(y_expr), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, TFLAGS },
    { "eof_action", "Action to take when encountering EOF from secondary input ",
        OFFSET(fs.opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT },
        EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, .unit = "eof_action" },
        { "repeat", "Repeat the previous frame.",   0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, .unit = "eof_action" },
        { "endall", "End both streams.",            0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, .unit = "eof_action" },
        { "pass",   "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS },   .flags = FLAGS, .unit = "eof_action" },
    { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_FRAME}, 0, EVAL_MODE_NB-1, FLAGS, .unit = "eval" },
         { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },
         { "frame", "eval expressions per-frame",                  0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
    { "shortest", "force termination when the shortest input terminates", OFFSET(fs.opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
    { "format", "set output format", OFFSET(format), AV_OPT_TYPE_INT, {.i64=OVERLAY_FORMAT_YUV420}, 0, OVERLAY_FORMAT_NB-1, FLAGS, .unit = "format" },
        { "yuv420", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV420}, .flags = FLAGS, .unit = "format" },
        { "yuv420p10", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV420P10}, .flags = FLAGS, .unit = "format" },
        { "yuv422", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV422}, .flags = FLAGS, .unit = "format" },
        { "yuv422p10", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV422P10}, .flags = FLAGS, .unit = "format" },
        { "yuv444", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV444}, .flags = FLAGS, .unit = "format" },
        { "yuv444p10", "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_YUV444P10}, .flags = FLAGS, .unit = "format" },
        { "rgb",    "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_RGB},    .flags = FLAGS, .unit = "format" },
        { "gbrp",   "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_GBRP},   .flags = FLAGS, .unit = "format" },
        { "auto",   "", 0, AV_OPT_TYPE_CONST, {.i64=OVERLAY_FORMAT_AUTO},   .flags = FLAGS, .unit = "format" },
    { "repeatlast", "repeat overlay of the last overlay frame", OFFSET(fs.opt_repeatlast), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, FLAGS },
    { "alpha", "alpha format", OFFSET(alpha_format), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "alpha_format" },
        { "straight",      "", 0, AV_OPT_TYPE_CONST, {.i64=0}, .flags = FLAGS, .unit = "alpha_format" },
        { "premultiplied", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, .flags = FLAGS, .unit = "alpha_format" },
    { NULL }
}

Definition at line 951 of file vf_overlay.c.

avfilter_vf_overlay_inputs

const AVFilterPad avfilter_vf_overlay_inputs[]

static

Initial value:

= {
    {
        .name         = "main",
        .type         = AVMEDIA_TYPE_VIDEO,
        .config_props = config_input_main,
    },
    {
        .name         = "overlay",
        .type         = AVMEDIA_TYPE_VIDEO,
        .config_props = config_input_overlay,
    },
}

Definition at line 983 of file vf_overlay.c.

avfilter_vf_overlay_outputs

const AVFilterPad avfilter_vf_overlay_outputs[]

static

Initial value:

= {
    {
        .name          = "default",
        .type          = AVMEDIA_TYPE_VIDEO,
        .config_props  = config_output,
    },
}

Definition at line 996 of file vf_overlay.c.

ff_vf_overlay

const AVFilter ff_vf_overlay

Initial value:

= {
    .name          = "overlay",
    .description   = NULL_IF_CONFIG_SMALL("Overlay a video source on top of the input."),
    .preinit       = overlay_framesync_preinit,
    .init          = init,
    .uninit        = uninit,
    .priv_size     = sizeof(OverlayContext),
    .priv_class    = &overlay_class,
    .activate      = activate,
    .process_command = process_command,
    FILTER_INPUTS(avfilter_vf_overlay_inputs),
    FILTER_OUTPUTS(avfilter_vf_overlay_outputs),
    FILTER_QUERY_FUNC2(query_formats),
    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL |
                     AVFILTER_FLAG_SLICE_THREADS,
}

Definition at line 1004 of file vf_overlay.c.