int eof_action; ///< action to take on EOF from source
AVExpr *x_pexpr, *y_pexpr;
+
+ void (*blend_image)(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y);
} OverlayContext;
static av_cold void uninit(AVFilterContext *ctx)
/* overlay formats contains alpha, for avoiding conversion with alpha information loss */
static const enum AVPixelFormat main_pix_fmts_yuv420[] = {
- AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE
+ AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE
};
static const enum AVPixelFormat overlay_pix_fmts_yuv420[] = {
AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE
};
static const enum AVPixelFormat main_pix_fmts_yuv422[] = {
- AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
+ AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
};
static const enum AVPixelFormat overlay_pix_fmts_yuv422[] = {
AV_PIX_FMT_YUVA422P, AV_PIX_FMT_NONE
};
static const enum AVPixelFormat main_pix_fmts_yuv444[] = {
- AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
+ AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
};
static const enum AVPixelFormat overlay_pix_fmts_yuv444[] = {
AV_PIX_FMT_YUVA444P, AV_PIX_FMT_NONE
}
static const enum AVPixelFormat alpha_pix_fmts[] = {
- AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA444P,
+ AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
AV_PIX_FMT_ARGB, AV_PIX_FMT_ABGR, AV_PIX_FMT_RGBA,
AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE
};
-static int config_input_main(AVFilterLink *inlink)
-{
- OverlayContext *s = inlink->dst->priv;
- const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
-
- av_image_fill_max_pixsteps(s->main_pix_step, NULL, pix_desc);
-
- s->hsub = pix_desc->log2_chroma_w;
- s->vsub = pix_desc->log2_chroma_h;
-
- s->main_is_packed_rgb =
- ff_fill_rgba_map(s->main_rgba_map, inlink->format) >= 0;
- s->main_has_alpha = ff_fmt_is_in(inlink->format, alpha_pix_fmts);
- return 0;
-}
-
static int config_input_overlay(AVFilterLink *inlink)
{
AVFilterContext *ctx = inlink->dst;
/**
* Blend image in src to destination buffer dst at position (x, y).
*/
-static void blend_image(AVFilterContext *ctx,
- AVFrame *dst, const AVFrame *src,
- int x, int y)
+
+static void blend_image_packed_rgb(AVFilterContext *ctx,
+ AVFrame *dst, const AVFrame *src,
+ int x, int y)
{
OverlayContext *s = ctx->priv;
- int i, imax, j, jmax, k, kmax;
+ int i, imax, j, jmax;
const int src_w = src->width;
const int src_h = src->height;
const int dst_w = dst->width;
const int dst_h = dst->height;
+ uint8_t alpha; ///< the amount of overlay to blend on to main
+ const int dr = s->main_rgba_map[R];
+ const int dg = s->main_rgba_map[G];
+ const int db = s->main_rgba_map[B];
+ const int da = s->main_rgba_map[A];
+ const int dstep = s->main_pix_step[0];
+ const int sr = s->overlay_rgba_map[R];
+ const int sg = s->overlay_rgba_map[G];
+ const int sb = s->overlay_rgba_map[B];
+ const int sa = s->overlay_rgba_map[A];
+ const int sstep = s->overlay_pix_step[0];
+ const int main_has_alpha = s->main_has_alpha;
+ uint8_t *S, *sp, *d, *dp;
+
+ i = FFMAX(-y, 0);
+ sp = src->data[0] + i * src->linesize[0];
+ dp = dst->data[0] + (y+i) * dst->linesize[0];
+
+ for (imax = FFMIN(-y + dst_h, src_h); i < imax; i++) {
+ j = FFMAX(-x, 0);
+ S = sp + j * sstep;
+ d = dp + (x+j) * dstep;
+
+ for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) {
+ alpha = S[sa];
+
+ // if the main channel has an alpha channel, alpha has to be calculated
+ // to create an un-premultiplied (straight) alpha value
+ if (main_has_alpha && alpha != 0 && alpha != 255) {
+ uint8_t alpha_d = d[da];
+ alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
+ }
- if (x >= dst_w || x+src_w < 0 ||
- y >= dst_h || y+src_h < 0)
- return; /* no intersection */
-
- if (s->main_is_packed_rgb) {
- uint8_t alpha; ///< the amount of overlay to blend on to main
- const int dr = s->main_rgba_map[R];
- const int dg = s->main_rgba_map[G];
- const int db = s->main_rgba_map[B];
- const int da = s->main_rgba_map[A];
- const int dstep = s->main_pix_step[0];
- const int sr = s->overlay_rgba_map[R];
- const int sg = s->overlay_rgba_map[G];
- const int sb = s->overlay_rgba_map[B];
- const int sa = s->overlay_rgba_map[A];
- const int sstep = s->overlay_pix_step[0];
- const int main_has_alpha = s->main_has_alpha;
- uint8_t *s, *sp, *d, *dp;
-
- i = FFMAX(-y, 0);
- sp = src->data[0] + i * src->linesize[0];
- dp = dst->data[0] + (y+i) * dst->linesize[0];
-
- for (imax = FFMIN(-y + dst_h, src_h); i < imax; i++) {
- j = FFMAX(-x, 0);
- s = sp + j * sstep;
- d = dp + (x+j) * dstep;
-
- for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) {
- alpha = s[sa];
-
- // if the main channel has an alpha channel, alpha has to be calculated
- // to create an un-premultiplied (straight) alpha value
- if (main_has_alpha && alpha != 0 && alpha != 255) {
- uint8_t alpha_d = d[da];
- alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
- }
-
+ switch (alpha) {
+ case 0:
+ break;
+ case 255:
+ d[dr] = S[sr];
+ d[dg] = S[sg];
+ d[db] = S[sb];
+ break;
+ default:
+ // main_value = main_value * (1 - alpha) + overlay_value * alpha
+ // since alpha is in the range 0-255, the result must divided by 255
+ d[dr] = FAST_DIV255(d[dr] * (255 - alpha) + S[sr] * alpha);
+ d[dg] = FAST_DIV255(d[dg] * (255 - alpha) + S[sg] * alpha);
+ d[db] = FAST_DIV255(d[db] * (255 - alpha) + S[sb] * alpha);
+ }
+ if (main_has_alpha) {
switch (alpha) {
case 0:
break;
case 255:
- d[dr] = s[sr];
- d[dg] = s[sg];
- d[db] = s[sb];
+ d[da] = S[sa];
break;
default:
- // main_value = main_value * (1 - alpha) + overlay_value * alpha
- // since alpha is in the range 0-255, the result must divided by 255
- d[dr] = FAST_DIV255(d[dr] * (255 - alpha) + s[sr] * alpha);
- d[dg] = FAST_DIV255(d[dg] * (255 - alpha) + s[sg] * alpha);
- d[db] = FAST_DIV255(d[db] * (255 - alpha) + s[sb] * alpha);
- }
- if (main_has_alpha) {
- switch (alpha) {
- case 0:
- break;
- case 255:
- d[da] = s[sa];
- break;
- default:
- // apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha
- d[da] += FAST_DIV255((255 - d[da]) * s[sa]);
- }
+ // apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha
+ d[da] += FAST_DIV255((255 - d[da]) * S[sa]);
}
- d += dstep;
- s += sstep;
}
- dp += dst->linesize[0];
- sp += src->linesize[0];
+ d += dstep;
+ S += sstep;
}
- } else {
- const int main_has_alpha = s->main_has_alpha;
- if (main_has_alpha) {
- uint8_t alpha; ///< the amount of overlay to blend on to main
- uint8_t *s, *sa, *d, *da;
-
- i = FFMAX(-y, 0);
- sa = src->data[3] + i * src->linesize[3];
- da = dst->data[3] + (y+i) * dst->linesize[3];
-
- for (imax = FFMIN(-y + dst_h, src_h); i < imax; i++) {
- j = FFMAX(-x, 0);
- s = sa + j;
- d = da + x+j;
-
- for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) {
- alpha = *s;
- if (alpha != 0 && alpha != 255) {
- uint8_t alpha_d = *d;
- alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
- }
- switch (alpha) {
- case 0:
- break;
- case 255:
- *d = *s;
- break;
- default:
- // apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha
- *d += FAST_DIV255((255 - *d) * *s);
- }
- d += 1;
- s += 1;
- }
- da += dst->linesize[3];
- sa += src->linesize[3];
+ dp += dst->linesize[0];
+ sp += src->linesize[0];
+ }
+}
+
+static av_always_inline void blend_plane(AVFilterContext *ctx,
+ AVFrame *dst, const AVFrame *src,
+ int src_w, int src_h,
+ int dst_w, int dst_h,
+ int i, int hsub, int vsub,
+ int x, int y,
+ int main_has_alpha)
+{
+ int src_wp = AV_CEIL_RSHIFT(src_w, hsub);
+ int src_hp = AV_CEIL_RSHIFT(src_h, vsub);
+ int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub);
+ int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub);
+ int yp = y>>vsub;
+ int xp = x>>hsub;
+ uint8_t *s, *sp, *d, *dp, *a, *ap;
+ int jmax, j, k, kmax;
+
+ j = FFMAX(-yp, 0);
+ sp = src->data[i] + j * src->linesize[i];
+ dp = dst->data[i] + (yp+j) * dst->linesize[i];
+ ap = src->data[3] + (j<<vsub) * src->linesize[3];
+
+ for (jmax = FFMIN(-yp + dst_hp, src_hp); j < jmax; j++) {
+ k = FFMAX(-xp, 0);
+ d = dp + xp+k;
+ s = sp + k;
+ a = ap + (k<<hsub);
+
+ for (kmax = FFMIN(-xp + dst_wp, src_wp); k < kmax; k++) {
+ int alpha_v, alpha_h, alpha;
+
+ // average alpha for color components, improve quality
+ if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) {
+ alpha = (a[0] + a[src->linesize[3]] +
+ a[1] + a[src->linesize[3]+1]) >> 2;
+ } else if (hsub || vsub) {
+ alpha_h = hsub && k+1 < src_wp ?
+ (a[0] + a[1]) >> 1 : a[0];
+ alpha_v = vsub && j+1 < src_hp ?
+ (a[0] + a[src->linesize[3]]) >> 1 : a[0];
+ alpha = (alpha_v + alpha_h) >> 1;
+ } else
+ alpha = a[0];
+ // if the main channel has an alpha channel, alpha has to be calculated
+ // to create an un-premultiplied (straight) alpha value
+ if (main_has_alpha && alpha != 0 && alpha != 255) {
+ // average alpha for color components, improve quality
+ uint8_t alpha_d;
+ if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) {
+ alpha_d = (d[0] + d[src->linesize[3]] +
+ d[1] + d[src->linesize[3]+1]) >> 2;
+ } else if (hsub || vsub) {
+ alpha_h = hsub && k+1 < src_wp ?
+ (d[0] + d[1]) >> 1 : d[0];
+ alpha_v = vsub && j+1 < src_hp ?
+ (d[0] + d[src->linesize[3]]) >> 1 : d[0];
+ alpha_d = (alpha_v + alpha_h) >> 1;
+ } else
+ alpha_d = d[0];
+ alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
}
+ *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha);
+ s++;
+ d++;
+ a += 1 << hsub;
}
- for (i = 0; i < 3; i++) {
- int hsub = i ? s->hsub : 0;
- int vsub = i ? s->vsub : 0;
- int src_wp = AV_CEIL_RSHIFT(src_w, hsub);
- int src_hp = AV_CEIL_RSHIFT(src_h, vsub);
- int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub);
- int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub);
- int yp = y>>vsub;
- int xp = x>>hsub;
- uint8_t *s, *sp, *d, *dp, *a, *ap;
-
- j = FFMAX(-yp, 0);
- sp = src->data[i] + j * src->linesize[i];
- dp = dst->data[i] + (yp+j) * dst->linesize[i];
- ap = src->data[3] + (j<<vsub) * src->linesize[3];
-
- for (jmax = FFMIN(-yp + dst_hp, src_hp); j < jmax; j++) {
- k = FFMAX(-xp, 0);
- d = dp + xp+k;
- s = sp + k;
- a = ap + (k<<hsub);
-
- for (kmax = FFMIN(-xp + dst_wp, src_wp); k < kmax; k++) {
- int alpha_v, alpha_h, alpha;
-
- // average alpha for color components, improve quality
- if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) {
- alpha = (a[0] + a[src->linesize[3]] +
- a[1] + a[src->linesize[3]+1]) >> 2;
- } else if (hsub || vsub) {
- alpha_h = hsub && k+1 < src_wp ?
- (a[0] + a[1]) >> 1 : a[0];
- alpha_v = vsub && j+1 < src_hp ?
- (a[0] + a[src->linesize[3]]) >> 1 : a[0];
- alpha = (alpha_v + alpha_h) >> 1;
- } else
- alpha = a[0];
- // if the main channel has an alpha channel, alpha has to be calculated
- // to create an un-premultiplied (straight) alpha value
- if (main_has_alpha && alpha != 0 && alpha != 255) {
- // average alpha for color components, improve quality
- uint8_t alpha_d;
- if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) {
- alpha_d = (d[0] + d[src->linesize[3]] +
- d[1] + d[src->linesize[3]+1]) >> 2;
- } else if (hsub || vsub) {
- alpha_h = hsub && k+1 < src_wp ?
- (d[0] + d[1]) >> 1 : d[0];
- alpha_v = vsub && j+1 < src_hp ?
- (d[0] + d[src->linesize[3]]) >> 1 : d[0];
- alpha_d = (alpha_v + alpha_h) >> 1;
- } else
- alpha_d = d[0];
- alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
- }
- *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha);
- s++;
- d++;
- a += 1 << hsub;
- }
- dp += dst->linesize[i];
- sp += src->linesize[i];
- ap += (1 << vsub) * src->linesize[3];
+ dp += dst->linesize[i];
+ sp += src->linesize[i];
+ ap += (1 << vsub) * src->linesize[3];
+ }
+}
+
+static inline void alpha_composite(const AVFrame *src, const AVFrame *dst,
+ int src_w, int src_h,
+ int dst_w, int dst_h,
+ int x, int y)
+{
+ uint8_t alpha; ///< the amount of overlay to blend on to main
+ uint8_t *s, *sa, *d, *da;
+ int i, imax, j, jmax;
+
+ i = FFMAX(-y, 0);
+ sa = src->data[3] + i * src->linesize[3];
+ da = dst->data[3] + (y+i) * dst->linesize[3];
+
+ for (imax = FFMIN(-y + dst_h, src_h); i < imax; i++) {
+ j = FFMAX(-x, 0);
+ s = sa + j;
+ d = da + x+j;
+
+ for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) {
+ alpha = *s;
+ if (alpha != 0 && alpha != 255) {
+ uint8_t alpha_d = *d;
+ alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d);
+ }
+ switch (alpha) {
+ case 0:
+ break;
+ case 255:
+ *d = *s;
+ break;
+ default:
+ // apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha
+ *d += FAST_DIV255((255 - *d) * *s);
}
+ d += 1;
+ s += 1;
}
+ da += dst->linesize[3];
+ sa += src->linesize[3];
+ }
+}
+
+static av_always_inline void blend_image_yuv(AVFilterContext *ctx,
+ AVFrame *dst, const AVFrame *src,
+ int hsub, int vsub,
+ int main_has_alpha,
+ int x, int y)
+{
+ const int src_w = src->width;
+ const int src_h = src->height;
+ const int dst_w = dst->width;
+ const int dst_h = dst->height;
+
+ if (main_has_alpha)
+ alpha_composite(src, dst, src_w, src_h, dst_w, dst_h, x, y);
+
+ blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, x, y, main_has_alpha);
+ blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha);
+ blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha);
+}
+
+static void blend_image_yuv420(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+ OverlayContext *s = ctx->priv;
+
+ blend_image_yuv(ctx, dst, src, 1, 1, s->main_has_alpha, x, y);
+}
+
+static void blend_image_yuv422(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+ OverlayContext *s = ctx->priv;
+
+ blend_image_yuv(ctx, dst, src, 1, 0, s->main_has_alpha, x, y);
+}
+
+static void blend_image_yuv444(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
+{
+ OverlayContext *s = ctx->priv;
+
+ blend_image_yuv(ctx, dst, src, 0, 0, s->main_has_alpha, x, y);
+}
+
+static int config_input_main(AVFilterLink *inlink)
+{
+ OverlayContext *s = inlink->dst->priv;
+ const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
+
+ av_image_fill_max_pixsteps(s->main_pix_step, NULL, pix_desc);
+
+ s->hsub = pix_desc->log2_chroma_w;
+ s->vsub = pix_desc->log2_chroma_h;
+
+ s->main_is_packed_rgb =
+ ff_fill_rgba_map(s->main_rgba_map, inlink->format) >= 0;
+ s->main_has_alpha = ff_fmt_is_in(inlink->format, alpha_pix_fmts);
+ switch (s->format) {
+ case OVERLAY_FORMAT_YUV420:
+ s->blend_image = blend_image_yuv420;
+ break;
+ case OVERLAY_FORMAT_YUV422:
+ s->blend_image = blend_image_yuv422;
+ break;
+ case OVERLAY_FORMAT_YUV444:
+ s->blend_image = blend_image_yuv444;
+ break;
+ case OVERLAY_FORMAT_RGB:
+ s->blend_image = blend_image_packed_rgb;
+ break;
}
+ return 0;
}
static AVFrame *do_blend(AVFilterContext *ctx, AVFrame *mainpic,
s->var_values[VAR_Y], s->y);
}
- blend_image(ctx, mainpic, second, s->x, s->y);
+ if (s->x < mainpic->width && s->x + second->width >= 0 ||
+ s->y < mainpic->height && s->y + second->height >= 0)
+ s->blend_image(ctx, mainpic, second, s->x, s->y);
return mainpic;
}
projects / ffmpeg / blobdiff