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[] = {
207 static const enum AVPixelFormat main_pix_fmts_yuv444p10[] = {
210 static const enum AVPixelFormat overlay_pix_fmts_yuv444p10[] = {
239 main_formats = main_pix_fmts_yuv420;
240 overlay_formats = overlay_pix_fmts_yuv420;
243 main_formats = main_pix_fmts_yuv420p10;
244 overlay_formats = overlay_pix_fmts_yuv420p10;
247 main_formats = main_pix_fmts_yuv422;
248 overlay_formats = overlay_pix_fmts_yuv422;
251 main_formats = main_pix_fmts_yuv422p10;
252 overlay_formats = overlay_pix_fmts_yuv422p10;
255 main_formats = main_pix_fmts_yuv444;
256 overlay_formats = overlay_pix_fmts_yuv444;
259 main_formats = main_pix_fmts_yuv444p10;
260 overlay_formats = overlay_pix_fmts_yuv444p10;
263 main_formats = main_pix_fmts_rgb;
264 overlay_formats = overlay_pix_fmts_rgb;
267 main_formats = main_pix_fmts_gbrp;
268 overlay_formats = overlay_pix_fmts_gbrp;
314 s->overlay_is_packed_rgb =
326 "main w:%d h:%d fmt:%s overlay w:%d h:%d fmt:%s\n",
352 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
358 #define UNPREMULTIPLY_ALPHA(x, y) ((((x) << 16) - ((x) << 9) + (x)) / ((((x) + (y)) << 8) - ((x) + (y)) - (y) * (x)))
366 int main_has_alpha,
int x,
int y,
367 int is_straight,
int jobnr,
int nb_jobs)
370 int i, imax, j, jmax;
371 const int src_w =
src->width;
372 const int src_h =
src->height;
373 const int dst_w =
dst->width;
374 const int dst_h =
dst->height;
376 const int dr =
s->main_rgba_map[
R];
377 const int dg =
s->main_rgba_map[
G];
378 const int db =
s->main_rgba_map[
B];
379 const int da =
s->main_rgba_map[
A];
380 const int dstep =
s->main_pix_step[0];
381 const int sr =
s->overlay_rgba_map[
R];
382 const int sg =
s->overlay_rgba_map[
G];
383 const int sb =
s->overlay_rgba_map[
B];
384 const int sa =
s->overlay_rgba_map[
A];
385 const int sstep =
s->overlay_pix_step[0];
387 uint8_t *
S, *sp, *d, *dp;
390 imax =
FFMIN3(-y + dst_h,
FFMIN(src_h, dst_h), y + src_h);
401 d = dp + (x+j) * dstep;
403 for (jmax =
FFMIN(-x + dst_w, src_w); j < jmax; j++) {
408 if (main_has_alpha &&
alpha != 0 &&
alpha != 255) {
409 uint8_t alpha_d = d[da];
431 if (main_has_alpha) {
446 dp +=
dst->linesize[0];
447 sp +=
src->linesize[0];
451 #define DEFINE_BLEND_PLANE(depth, nbits) \
452 static av_always_inline void blend_plane_##depth##_##nbits##bits(AVFilterContext *ctx, \
453 AVFrame *dst, const AVFrame *src, \
454 int src_w, int src_h, \
455 int dst_w, int dst_h, \
456 int i, int hsub, int vsub, \
458 int main_has_alpha, \
467 OverlayContext *octx = ctx->priv; \
468 int src_wp = AV_CEIL_RSHIFT(src_w, hsub); \
469 int src_hp = AV_CEIL_RSHIFT(src_h, vsub); \
470 int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub); \
471 int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub); \
474 uint##depth##_t *s, *sp, *d, *dp, *dap, *a, *da, *ap; \
475 int jmax, j, k, kmax; \
476 int slice_start, slice_end; \
477 const uint##depth##_t max = (1 << nbits) - 1; \
478 const uint##depth##_t mid = (1 << (nbits -1)) ; \
479 int bytes = depth / 8; \
483 jmax = FFMIN3(-yp + dst_hp, FFMIN(src_hp, dst_hp), yp + src_hp); \
485 slice_start = j + (jmax * jobnr) / nb_jobs; \
486 slice_end = j + (jmax * (jobnr+1)) / nb_jobs; \
488 sp = (uint##depth##_t *)(src->data[i] + (slice_start) * src->linesize[i]); \
489 dp = (uint##depth##_t *)(dst->data[dst_plane] \
490 + (yp + slice_start) * dst->linesize[dst_plane] \
492 ap = (uint##depth##_t *)(src->data[3] + (slice_start << vsub) * src->linesize[3]); \
493 dap = (uint##depth##_t *)(dst->data[3] + ((yp + slice_start) << vsub) * dst->linesize[3]); \
495 for (j = slice_start; j < slice_end; j++) { \
497 d = dp + (xp+k) * dst_step; \
499 a = ap + (k<<hsub); \
500 da = dap + ((xp+k) << hsub); \
501 kmax = FFMIN(-xp + dst_wp, src_wp); \
503 if (nbits == 8 && ((vsub && j+1 < src_hp) || !vsub) && octx->blend_row[i]) { \
504 int c = octx->blend_row[i]((uint8_t*)d, (uint8_t*)da, (uint8_t*)s, \
505 (uint8_t*)a, kmax - k, src->linesize[3]); \
509 da += (1 << hsub) * c; \
510 a += (1 << hsub) * c; \
513 for (; k < kmax; k++) { \
514 int alpha_v, alpha_h, alpha; \
517 if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
518 alpha = (a[0] + a[src->linesize[3]] + \
519 a[1] + a[src->linesize[3]+1]) >> 2; \
520 } else if (hsub || vsub) { \
521 alpha_h = hsub && k+1 < src_wp ? \
522 (a[0] + a[1]) >> 1 : a[0]; \
523 alpha_v = vsub && j+1 < src_hp ? \
524 (a[0] + a[src->linesize[3]]) >> 1 : a[0]; \
525 alpha = (alpha_v + alpha_h) >> 1; \
530 if (main_has_alpha && alpha != 0 && alpha != max) { \
533 if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
534 alpha_d = (da[0] + da[dst->linesize[3]] + \
535 da[1] + da[dst->linesize[3]+1]) >> 2; \
536 } else if (hsub || vsub) { \
537 alpha_h = hsub && k+1 < src_wp ? \
538 (da[0] + da[1]) >> 1 : da[0]; \
539 alpha_v = vsub && j+1 < src_hp ? \
540 (da[0] + da[dst->linesize[3]]) >> 1 : da[0]; \
541 alpha_d = (alpha_v + alpha_h) >> 1; \
544 alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
548 *d = (*d * (max - alpha) + *s * alpha) / max; \
550 *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha); \
554 *d = av_clip((*d * (max - alpha) + *s * alpha) / max + *s - mid, -mid, mid) + mid; \
556 *d = av_clip_uintp2((*d * (max - alpha) + *s * alpha) / max + *s - (16<<(nbits-8)),\
560 *d = av_clip(FAST_DIV255((*d - mid) * (max - alpha)) + *s - mid, -mid, mid) + mid; \
562 *d = av_clip_uint8(FAST_DIV255(*d * (255 - alpha)) + *s - 16); \
570 dp += dst->linesize[dst_plane] / bytes; \
571 sp += src->linesize[i] / bytes; \
572 ap += (1 << vsub) * src->linesize[3] / bytes; \
573 dap += (1 << vsub) * dst->linesize[3] / bytes; \
579 #define DEFINE_ALPHA_COMPOSITE(depth, nbits) \
580 static inline void alpha_composite_##depth##_##nbits##bits(const AVFrame *src, const AVFrame *dst, \
581 int src_w, int src_h, \
582 int dst_w, int dst_h, \
584 int jobnr, int nb_jobs) \
586 uint##depth##_t alpha; \
587 uint##depth##_t *s, *sa, *d, *da; \
588 int i, imax, j, jmax; \
589 int slice_start, slice_end; \
590 const uint##depth##_t max = (1 << nbits) - 1; \
591 int bytes = depth / 8; \
593 imax = FFMIN3(-y + dst_h, FFMIN(src_h, dst_h), y + src_h); \
596 slice_start = i + (imax * jobnr) / nb_jobs; \
597 slice_end = i + ((imax * (jobnr+1)) / nb_jobs); \
599 sa = (uint##depth##_t *)(src->data[3] + (slice_start) * src->linesize[3]); \
600 da = (uint##depth##_t *)(dst->data[3] + (y + slice_start) * dst->linesize[3]); \
602 for (i = slice_start; i < slice_end; i++) { \
607 for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) { \
609 if (alpha != 0 && alpha != max) { \
610 uint8_t alpha_d = *d; \
611 alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
615 else if (alpha > 0) { \
618 *d += (max - *d) * *s / max; \
620 *d += FAST_DIV255((max - *d) * *s); \
625 da += dst->linesize[3] / bytes; \
626 sa += src->linesize[3] / bytes; \
632 #define DEFINE_BLEND_SLICE_YUV(depth, nbits) \
633 static av_always_inline void blend_slice_yuv_##depth##_##nbits##bits(AVFilterContext *ctx, \
634 AVFrame *dst, const AVFrame *src, \
635 int hsub, int vsub, \
636 int main_has_alpha, \
639 int jobnr, int nb_jobs) \
641 OverlayContext *s = ctx->priv; \
642 const int src_w = src->width; \
643 const int src_h = src->height; \
644 const int dst_w = dst->width; \
645 const int dst_h = dst->height; \
647 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, \
648 x, y, main_has_alpha, s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, \
649 s->main_desc->comp[0].step, is_straight, 1, jobnr, nb_jobs); \
650 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, \
651 x, y, main_has_alpha, s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, \
652 s->main_desc->comp[1].step, is_straight, 1, jobnr, nb_jobs); \
653 blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, \
654 x, y, main_has_alpha, s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, \
655 s->main_desc->comp[2].step, is_straight, 1, jobnr, nb_jobs); \
657 if (main_has_alpha) \
658 alpha_composite_##depth##_##nbits##bits(src, dst, src_w, src_h, dst_w, dst_h, x, y, \
674 const int src_w =
src->width;
675 const int src_h =
src->height;
676 const int dst_w =
dst->width;
677 const int dst_h =
dst->height;
679 blend_plane_8_8bits(
ctx,
dst,
src, src_w, src_h, dst_w, dst_h, 0, 0, 0, x, y, main_has_alpha,
680 s->main_desc->comp[1].plane,
s->main_desc->comp[1].offset,
s->main_desc->comp[1].step, is_straight, 0,
682 blend_plane_8_8bits(
ctx,
dst,
src, src_w, src_h, dst_w, dst_h, 1,
hsub, vsub, x, y, main_has_alpha,
683 s->main_desc->comp[2].plane,
s->main_desc->comp[2].offset,
s->main_desc->comp[2].step, is_straight, 0,
685 blend_plane_8_8bits(
ctx,
dst,
src, src_w, src_h, dst_w, dst_h, 2,
hsub, vsub, x, y, main_has_alpha,
686 s->main_desc->comp[0].plane,
s->main_desc->comp[0].offset,
s->main_desc->comp[0].step, is_straight, 0,
690 alpha_composite_8_8bits(
src,
dst, src_w, src_h, dst_w, dst_h, x, y, jobnr, nb_jobs);
693 #define DEFINE_BLEND_SLICE_PLANAR_FMT(format_, blend_slice_fn_suffix_, hsub_, vsub_, main_has_alpha_, direct_) \
694 static int blend_slice_##format_(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
696 OverlayContext *s = ctx->priv; \
697 ThreadData *td = arg; \
698 blend_slice_##blend_slice_fn_suffix_(ctx, td->dst, td->src, \
699 hsub_, vsub_, main_has_alpha_, \
700 s->x, s->y, direct_, \
729 #define DEFINE_BLEND_SLICE_PACKED_FMT(format_, blend_slice_fn_suffix_, main_has_alpha_, direct_) \
730 static int blend_slice_##format_(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
732 OverlayContext *s = ctx->priv; \
733 ThreadData *td = arg; \
734 blend_slice_packed_##blend_slice_fn_suffix_(ctx, td->dst, td->src, \
736 s->x, s->y, direct_, \
757 s->main_desc = pix_desc;
759 s->main_is_packed_rgb =
764 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva420 : blend_slice_yuv420;
767 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva420p10 : blend_slice_yuv420p10;
770 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva422 : blend_slice_yuv422;
773 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva422p10 : blend_slice_yuv422p10;
776 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva444 : blend_slice_yuv444;
779 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva444p10 : blend_slice_yuv444p10;
782 s->blend_slice =
s->main_has_alpha ? blend_slice_rgba : blend_slice_rgb;
785 s->blend_slice =
s->main_has_alpha ? blend_slice_gbrap : blend_slice_gbrp;
790 s->blend_slice = blend_slice_yuva420;
793 s->blend_slice = blend_slice_yuva420p10;
796 s->blend_slice = blend_slice_yuva422;
799 s->blend_slice = blend_slice_yuva422p10;
802 s->blend_slice = blend_slice_yuva444;
805 s->blend_slice = blend_slice_yuva444p10;
811 s->blend_slice = blend_slice_rgba;
814 s->blend_slice = blend_slice_gbrap;
823 if (!
s->alpha_format)
828 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva420_pm : blend_slice_yuv420_pm;
831 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva422_pm : blend_slice_yuv422_pm;
834 s->blend_slice =
s->main_has_alpha ? blend_slice_yuva444_pm : blend_slice_yuv444_pm;
837 s->blend_slice =
s->main_has_alpha ? blend_slice_rgba_pm : blend_slice_rgb_pm;
840 s->blend_slice =
s->main_has_alpha ? blend_slice_gbrap_pm : blend_slice_gbrp_pm;
845 s->blend_slice = blend_slice_yuva420_pm;
848 s->blend_slice = blend_slice_yuva422_pm;
851 s->blend_slice = blend_slice_yuva444_pm;
857 s->blend_slice = blend_slice_rgba_pm;
860 s->blend_slice = blend_slice_gbrap_pm;
872 s->alpha_format,
s->main_has_alpha);
919 if (
s->x < mainpic->
width &&
s->x + second->
width >= 0 &&
945 #define OFFSET(x) offsetof(OverlayContext, x)
946 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
951 {
"eof_action",
"Action to take when encountering EOF from secondary input ",
960 {
"shortest",
"force termination when the shortest input terminates",
OFFSET(
fs.opt_shortest),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
FLAGS },
1004 .preinit = overlay_framesync_preinit,
1008 .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 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 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
#define FILTER_INPUTS(array)
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 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...
const char * name
Filter name.
A link between two filters.
#define AV_PIX_FMT_YUVA422P10
Link properties exposed to filter code, but not external callers.
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 slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
@ 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.
#define DEFINE_BLEND_SLICE_PACKED_FMT(format_, blend_slice_fn_suffix_, main_has_alpha_, direct_)
void ff_overlay_init_x86(OverlayContext *s, int format, int pix_format, int alpha_format, int main_has_alpha)
#define AV_PIX_FMT_YUV444P10
#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)
@ 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 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.
int ff_fmt_is_in(int fmt, const int *fmts)
Tell if an integer is contained in the provided -1-terminated list of integers.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static void eval_expr(AVFilterContext *ctx)
#define FILTER_OUTPUTS(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 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
@ AV_PIX_FMT_ABGR
packed ABGR 8:8:8:8, 32bpp, ABGRABGR...
static const AVFilterPad avfilter_vf_overlay_inputs[]
static FilterLink * ff_filter_link(AVFilterLink *link)
@ 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
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
#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)
@ OVERLAY_FORMAT_YUV444P10
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
#define AV_PIX_FMT_YUVA444P10
#define DEFINE_ALPHA_COMPOSITE(depth, nbits)
@ AV_PIX_FMT_ARGB
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
#define DEFINE_BLEND_SLICE_PLANAR_FMT(format_, blend_slice_fn_suffix_, hsub_, vsub_, main_has_alpha_, direct_)
#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 normalize_xy(double d, int chroma_sub)
static int slice_start(SliceContext *sc, VVCContext *s, VVCFrameContext *fc, const CodedBitstreamUnit *unit, const int is_first_slice)
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)
int h
agreed upon image height
int ff_filter_execute(AVFilterContext *ctx, avfilter_action_func *func, void *arg, int *ret, int nb_jobs)
@ AV_OPT_TYPE_INT
Underlying C type is int.
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)
#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[]
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
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 ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
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[]
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
#define FILTER_QUERY_FUNC(func)
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 av_cold int init(AVFilterContext *ctx)