Go to the documentation of this file.
96 return (
int)
d & ~((1 << chroma_sub) - 1);
122 "Error when evaluating the expression '%s' for %s\n",
133 char *res,
int res_len,
int flags)
138 if (!strcmp(cmd,
"x"))
140 else if (!strcmp(cmd,
"y"))
174 static const enum AVPixelFormat overlay_pix_fmts_yuv420[] = {
178 static const enum AVPixelFormat main_pix_fmts_yuv420p10[] = {
182 static const enum AVPixelFormat overlay_pix_fmts_yuv420p10[] = {
189 static const enum AVPixelFormat overlay_pix_fmts_yuv422[] = {
193 static const enum AVPixelFormat main_pix_fmts_yuv422p10[] = {
196 static const enum AVPixelFormat overlay_pix_fmts_yuv422p10[] = {
203 static const enum AVPixelFormat overlay_pix_fmts_yuv444[] = {
232 main_formats = main_pix_fmts_yuv420;
233 overlay_formats = overlay_pix_fmts_yuv420;
236 main_formats = main_pix_fmts_yuv420p10;
237 overlay_formats = overlay_pix_fmts_yuv420p10;
240 main_formats = main_pix_fmts_yuv422;
241 overlay_formats = overlay_pix_fmts_yuv422;
244 main_formats = main_pix_fmts_yuv422p10;
245 overlay_formats = overlay_pix_fmts_yuv422p10;
248 main_formats = main_pix_fmts_yuv444;
249 overlay_formats = overlay_pix_fmts_yuv444;
252 main_formats = main_pix_fmts_rgb;
253 overlay_formats = overlay_pix_fmts_rgb;
256 main_formats = main_pix_fmts_gbrp;
257 overlay_formats = overlay_pix_fmts_gbrp;
303 s->overlay_is_packed_rgb =
315 "main w:%d h:%d fmt:%s overlay w:%d h:%d fmt:%s\n",
341 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
347 #define UNPREMULTIPLY_ALPHA(x, y) ((((x) << 16) - ((x) << 9) + (x)) / ((((x) + (y)) << 8) - ((x) + (y)) - (y) * (x)))
355 int main_has_alpha,
int x,
int y,
356 int is_straight,
int jobnr,
int nb_jobs)
359 int i, imax, j, jmax;
360 const int src_w =
src->width;
361 const int src_h =
src->height;
362 const int dst_w = dst->
width;
363 const int dst_h = dst->
height;
365 const int dr =
s->main_rgba_map[
R];
366 const int dg =
s->main_rgba_map[
G];
367 const int db =
s->main_rgba_map[
B];
368 const int da =
s->main_rgba_map[
A];
369 const int dstep =
s->main_pix_step[0];
370 const int sr =
s->overlay_rgba_map[
R];
371 const int sg =
s->overlay_rgba_map[
G];
372 const int sb =
s->overlay_rgba_map[
B];
373 const int sa =
s->overlay_rgba_map[
A];
374 const int sstep =
s->overlay_pix_step[0];
376 uint8_t *
S, *
sp, *
d, *dp;
379 imax =
FFMIN3(-y + dst_h,
FFMIN(src_h, dst_h), y + src_h);
381 slice_start =
i + (imax * jobnr) / nb_jobs;
384 sp =
src->data[0] + (slice_start) *
src->linesize[0];
385 dp = dst->
data[0] + (y + slice_start) * dst->
linesize[0];
390 d = dp + (x+j) * dstep;
392 for (jmax =
FFMIN(-x + dst_w, src_w); j < jmax; j++) {
397 if (main_has_alpha &&
alpha != 0 &&
alpha != 255) {
398 uint8_t alpha_d =
d[da];
420 if (main_has_alpha) {
436 sp +=
src->linesize[0];
440 #define DEFINE_BLEND_PLANE(depth, nbits) \
441 static av_always_inline void blend_plane_##depth##_##nbits##bits(AVFilterContext *ctx, \
442 AVFrame *dst, const AVFrame *src, \
443 int src_w, int src_h, \
444 int dst_w, int dst_h, \
445 int i, int hsub, int vsub, \
447 int main_has_alpha, \
456 OverlayContext *octx = ctx->priv; \
457 int src_wp = AV_CEIL_RSHIFT(src_w, hsub); \
458 int src_hp = AV_CEIL_RSHIFT(src_h, vsub); \
459 int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub); \
460 int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub); \
463 uint##depth##_t *s, *sp, *d, *dp, *dap, *a, *da, *ap; \
464 int jmax, j, k, kmax; \
465 int slice_start, slice_end; \
466 const uint##depth##_t max = (1 << nbits) - 1; \
467 const uint##depth##_t mid = (1 << (nbits -1)) ; \
468 int bytes = depth / 8; \
472 jmax = FFMIN3(-yp + dst_hp, FFMIN(src_hp, dst_hp), yp + src_hp); \
474 slice_start = j + (jmax * jobnr) / nb_jobs; \
475 slice_end = j + (jmax * (jobnr+1)) / nb_jobs; \
477 sp = (uint##depth##_t *)(src->data[i] + (slice_start) * src->linesize[i]); \
478 dp = (uint##depth##_t *)(dst->data[dst_plane] \
479 + (yp + slice_start) * dst->linesize[dst_plane] \
481 ap = (uint##depth##_t *)(src->data[3] + (slice_start << vsub) * src->linesize[3]); \
482 dap = (uint##depth##_t *)(dst->data[3] + ((yp + slice_start) << vsub) * dst->linesize[3]); \
484 for (j = slice_start; j < slice_end; j++) { \
486 d = dp + (xp+k) * dst_step; \
488 a = ap + (k<<hsub); \
489 da = dap + ((xp+k) << hsub); \
490 kmax = FFMIN(-xp + dst_wp, src_wp); \
492 if (nbits == 8 && ((vsub && j+1 < src_hp) || !vsub) && octx->blend_row[i]) { \
493 int c = octx->blend_row[i]((uint8_t*)d, (uint8_t*)da, (uint8_t*)s, \
494 (uint8_t*)a, kmax - k, src->linesize[3]); \
498 da += (1 << hsub) * c; \
499 a += (1 << hsub) * c; \
502 for (; k < kmax; k++) { \
503 int alpha_v, alpha_h, alpha; \
506 if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
507 alpha = (a[0] + a[src->linesize[3]] + \
508 a[1] + a[src->linesize[3]+1]) >> 2; \
509 } else if (hsub || vsub) { \
510 alpha_h = hsub && k+1 < src_wp ? \
511 (a[0] + a[1]) >> 1 : a[0]; \
512 alpha_v = vsub && j+1 < src_hp ? \
513 (a[0] + a[src->linesize[3]]) >> 1 : a[0]; \
514 alpha = (alpha_v + alpha_h) >> 1; \
519 if (main_has_alpha && alpha != 0 && alpha != max) { \
522 if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
523 alpha_d = (da[0] + da[dst->linesize[3]] + \
524 da[1] + da[dst->linesize[3]+1]) >> 2; \
525 } else if (hsub || vsub) { \
526 alpha_h = hsub && k+1 < src_wp ? \
527 (da[0] + da[1]) >> 1 : da[0]; \
528 alpha_v = vsub && j+1 < src_hp ? \
529 (da[0] + da[dst->linesize[3]]) >> 1 : da[0]; \
530 alpha_d = (alpha_v + alpha_h) >> 1; \
533 alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
537 *d = (*d * (max - alpha) + *s * alpha) / max; \
539 *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha); \
543 *d = av_clip((*d * (max - alpha) + *s * alpha) / max + *s - mid, -mid, mid) + mid; \
545 *d = av_clip_uintp2((*d * (max - alpha) + *s * alpha) / max + *s - (16<<(nbits-8)),\
549 *d = av_clip(FAST_DIV255((*d - mid) * (max - alpha)) + *s - mid, -mid, mid) + mid; \
551 *d = av_clip_uint8(FAST_DIV255(*d * (255 - alpha)) + *s - 16); \
559 dp += dst->linesize[dst_plane] / bytes; \
560 sp += src->linesize[i] / bytes; \
561 ap += (1 << vsub) * src->linesize[3] / bytes; \
562 dap += (1 << vsub) * dst->linesize[3] / bytes; \
568 #define DEFINE_ALPHA_COMPOSITE(depth, nbits) \
569 static inline void alpha_composite_##depth##_##nbits##bits(const AVFrame *src, const AVFrame *dst, \
570 int src_w, int src_h, \
571 int dst_w, int dst_h, \
573 int jobnr, int nb_jobs) \
575 uint##depth##_t alpha; \
576 uint##depth##_t *s, *sa, *d, *da; \
577 int i, imax, j, jmax; \
578 int slice_start, slice_end; \
579 const uint##depth##_t max = (1 << nbits) - 1; \
580 int bytes = depth / 8; \
582 imax = FFMIN3(-y + dst_h, FFMIN(src_h, dst_h), y + src_h); \
585 slice_start = i + (imax * jobnr) / nb_jobs; \
586 slice_end = i + ((imax * (jobnr+1)) / nb_jobs); \
588 sa = (uint##depth##_t *)(src->data[3] + (slice_start) * src->linesize[3]); \
589 da = (uint##depth##_t *)(dst->data[3] + (y + slice_start) * dst->linesize[3]); \
591 for (i = slice_start; i < slice_end; i++) { \
596 for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) { \
598 if (alpha != 0 && alpha != max) { \
599 uint8_t alpha_d = *d; \
600 alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
604 else if (alpha > 0) { \
607 *d += (max - *d) * *s / max; \
609 *d += FAST_DIV255((max - *d) * *s); \
614 da += dst->linesize[3] / bytes; \
615 sa += src->linesize[3] / bytes; \
621 #define DEFINE_BLEND_SLICE_YUV(depth, nbits) \
622 static av_always_inline void blend_slice_yuv_##depth##_##nbits##bits(AVFilterContext *ctx, \
623 AVFrame *dst, const AVFrame *src, \
624 int hsub, int vsub, \
625 int main_has_alpha, \
628 int jobnr, int nb_jobs) \
630 OverlayContext *s = ctx->priv; \
631 const int src_w = src->width; \
632 const int src_h = src->height; \
633 const int dst_w = dst->width; \
634 const int dst_h = dst->height; \
636 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, \
637 x, y, main_has_alpha, s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, \
638 s->main_desc->comp[0].step, is_straight, 1, jobnr, nb_jobs); \
639 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, \
640 x, y, main_has_alpha, s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, \
641 s->main_desc->comp[1].step, is_straight, 1, jobnr, nb_jobs); \
642 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, \
643 x, y, main_has_alpha, s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, \
644 s->main_desc->comp[2].step, is_straight, 1, jobnr, nb_jobs); \
646 if (main_has_alpha) \
647 alpha_composite_##depth##_##nbits##bits(src, dst, src_w, src_h, dst_w, dst_h, x, y, \
663 const int src_w =
src->width;
664 const int src_h =
src->height;
665 const int dst_w = dst->width;
666 const int dst_h = dst->height;
668 blend_plane_8_8bits(
ctx, dst,
src, src_w, src_h, dst_w, dst_h, 0, 0, 0, x, y, main_has_alpha,
669 s->main_desc->comp[1].plane,
s->main_desc->comp[1].offset,
s->main_desc->comp[1].step, is_straight, 0,
671 blend_plane_8_8bits(
ctx, dst,
src, src_w, src_h, dst_w, dst_h, 1,
hsub, vsub, x, y, main_has_alpha,
672 s->main_desc->comp[2].plane,
s->main_desc->comp[2].offset,
s->main_desc->comp[2].step, is_straight, 0,
674 blend_plane_8_8bits(
ctx, dst,
src, src_w, src_h, dst_w, dst_h, 2,
hsub, vsub, x, y, main_has_alpha,
675 s->main_desc->comp[0].plane,
s->main_desc->comp[0].offset,
s->main_desc->comp[0].step, is_straight, 0,
679 alpha_composite_8_8bits(
src, dst, src_w, src_h, dst_w, dst_h, x, y, jobnr, nb_jobs);
686 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 1, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
694 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 1, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
702 blend_slice_yuv_16_10bits(
ctx,
td->dst,
td->src, 1, 1, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
710 blend_slice_yuv_16_10bits(
ctx,
td->dst,
td->src, 1, 1, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
718 blend_slice_yuv_16_10bits(
ctx,
td->dst,
td->src, 1, 0, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
726 blend_slice_yuv_16_10bits(
ctx,
td->dst,
td->src, 1, 0, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
734 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 0, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
742 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 0, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
750 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 0, 0, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
758 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 0, 0, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
766 blend_slice_planar_rgb(
ctx,
td->dst,
td->src, 0, 0, 0,
s->x,
s->y, 1, jobnr, nb_jobs);
774 blend_slice_planar_rgb(
ctx,
td->dst,
td->src, 0, 0, 1,
s->x,
s->y, 1, jobnr, nb_jobs);
782 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 1, 0,
s->x,
s->y, 0, jobnr, nb_jobs);
790 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 1, 1,
s->x,
s->y, 0, jobnr, nb_jobs);
798 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 0, 0,
s->x,
s->y, 0, jobnr, nb_jobs);
806 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 1, 0, 1,
s->x,
s->y, 0, jobnr, nb_jobs);
814 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 0, 0, 0,
s->x,
s->y, 0, jobnr, nb_jobs);
822 blend_slice_yuv_8_8bits(
ctx,
td->dst,
td->src, 0, 0, 1,
s->x,
s->y, 0, jobnr, nb_jobs);
830 blend_slice_planar_rgb(
ctx,
td->dst,
td->src, 0, 0, 0,
s->x,
s->y, 0, jobnr, nb_jobs);
838 blend_slice_planar_rgb(
ctx,
td->dst,
td->src, 0, 0, 1,
s->x,
s->y, 0, jobnr, nb_jobs);
884 s->main_desc = pix_desc;
886 s->main_is_packed_rgb =
944 if (!
s->alpha_format)
993 s->alpha_format,
s->main_has_alpha);
1018 #if FF_API_FRAME_PKT
1039 if (
s->x < mainpic->
width &&
s->x + second->
width >= 0 &&
1065 #define OFFSET(x) offsetof(OverlayContext, x)
1066 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
1071 {
"eof_action",
"Action to take when encountering EOF from secondary input ",
1080 {
"shortest",
"force termination when the shortest input terminates",
OFFSET(
fs.opt_shortest),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
FLAGS },
1123 .preinit = overlay_framesync_preinit,
1127 .priv_class = &overlay_class,
#define FF_ENABLE_DEPRECATION_WARNINGS
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
AVPixelFormat
Pixel format.
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).
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
static int blend_slice_rgb(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int set_expr(AVExpr **pexpr, const char *expr, const char *option, void *log_ctx)
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
static int blend_slice_yuv422(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static const AVFilterPad avfilter_vf_overlay_outputs[]
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
static int blend_slice_yuv422p10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int blend_slice_yuva422_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
This structure describes decoded (raw) audio or video data.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
static int do_blend(FFFrameSync *fs)
#define AV_PIX_FMT_YUVA420P10
#define FILTER_QUERY_FUNC(func)
#define AV_PIX_FMT_YUV420P10
#define AV_LOG_VERBOSE
Detailed information.
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
static int blend_slice_yuv420(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
const char * name
Filter name.
static int blend_slice_yuva422p10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
A link between two filters.
#define AV_PIX_FMT_YUVA422P10
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int blend_slice_gbrap(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
static const char *const var_names[]
static int blend_slice_gbrp_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
@ OVERLAY_FORMAT_YUV422P10
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
A filter pad used for either input or output.
void ff_overlay_init_x86(OverlayContext *s, int format, int pix_format, int alpha_format, int main_has_alpha)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static int config_input_main(AVFilterLink *inlink)
static int query_formats(AVFilterContext *ctx)
static int blend_slice_rgb_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
static double av_q2d(AVRational a)
Convert an AVRational to a double.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
#define UNPREMULTIPLY_ALPHA(x, y)
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static int blend_slice_yuva420p10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static void eval_expr(AVFilterContext *ctx)
#define FILTER_INPUTS(array)
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
const AVFilter ff_vf_overlay
static int config_input_overlay(AVFilterLink *inlink)
#define fs(width, name, subs,...)
static int blend_slice_yuva444_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static av_cold void uninit(AVFilterContext *ctx)
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
#define AV_PIX_FMT_YUV422P10
static int blend_slice_yuv420_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
static const AVFilterPad avfilter_vf_overlay_inputs[]
static int blend_slice_yuv420p10(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
static const AVOption overlay_options[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent)
Initialize a frame sync structure for dualinput.
@ OVERLAY_FORMAT_YUV420P10
#define AV_NOPTS_VALUE
Undefined timestamp value.
attribute_deprecated int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
AVFilterContext * src
source filter
static int config_output(AVFilterLink *outlink)
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
#define DEFINE_ALPHA_COMPOSITE(depth, nbits)
static int blend_slice_rgba(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int blend_slice_yuva420_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
static int blend_slice_gbrap_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int blend_slice_yuva444(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int blend_slice_rgba_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define i(width, name, range_min, range_max)
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)
int w
agreed upon image width
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Used for passing data between threads.
@ AV_PIX_FMT_NV21
as above, but U and V bytes are swapped
const char * name
Pad name.
static int blend_slice_gbrp(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int normalize_xy(double d, int chroma_sub)
static int blend_slice_yuv444(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
#define DEFINE_BLEND_PLANE(depth, nbits)
static int blend_slice_yuva422(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
int h
agreed upon image height
static int activate(AVFilterContext *ctx)
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link.
void av_image_fill_max_pixsteps(int max_pixsteps[4], int max_pixstep_comps[4], const AVPixFmtDescriptor *pixdesc)
Compute the max pixel step for each plane of an image with a format described by pixdesc.
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
static int blend_slice_yuv444_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
#define FF_DISABLE_DEPRECATION_WARNINGS
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
FRAMESYNC_DEFINE_CLASS(overlay, OverlayContext, fs)
static const int16_t alpha[]
#define FILTER_OUTPUTS(array)
int ff_fill_rgba_map(uint8_t *rgba_map, enum AVPixelFormat pix_fmt)
#define DEFINE_BLEND_SLICE_YUV(depth, nbits)
#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL
Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will have its filter_frame() c...
#define flags(name, subs,...)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
int ff_framesync_dualinput_get_writable(FFFrameSync *fs, AVFrame **f0, AVFrame **f1)
Same as ff_framesync_dualinput_get(), but make sure that f0 is writable.
static enum AVPixelFormat alpha_pix_fmts[]
static av_always_inline int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
static int blend_slice_yuva420(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
static int blend_slice_yuv422_pm(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
static av_cold int init(AVFilterContext *ctx)