highperfocused/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

avfilter/vf_overlay: support for 8bit and 10bit overlay with macro-based function

Browse Source 
Signed-off-by: Limin Wang <lance.lmwang@gmail.com>
This commit is contained in:
Limin Wang
2020-06-05 21:58:00 +08:00
parent e3b5897fe3
commit 4d787c16e8
1 changed files with 218 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
libavfilter/vf_overlay.c
View File

@ -441,190 +441,213 @@ static av_always_inline void blend_slice_packed_rgb(AVFilterContext *ctx,
} }
} }
static av_always_inline void blend_plane(AVFilterContext *ctx, #define DEFINE_BLEND_PLANE(depth, nbits) \
AVFrame *dst, const AVFrame *src, static av_always_inline void blend_plane_##depth##_##nbits##bits(AVFilterContext *ctx, \
int src_w, int src_h, AVFrame *dst, const AVFrame *src, \
int dst_w, int dst_h, int src_w, int src_h, \
int i, int hsub, int vsub, int dst_w, int dst_h, \
int x, int y, int i, int hsub, int vsub, \
int main_has_alpha, int x, int y, \
int dst_plane, int main_has_alpha, \
int dst_offset, int dst_plane, \
int dst_step, int dst_offset, \
int straight, int dst_step, \
int yuv, int straight, \
int jobnr, int yuv, \
int nb_jobs) int jobnr, \
{ int nb_jobs) \
OverlayContext *octx = ctx->priv; { \
int src_wp = AV_CEIL_RSHIFT(src_w, hsub); OverlayContext *octx = ctx->priv; \
int src_hp = AV_CEIL_RSHIFT(src_h, vsub); int src_wp = AV_CEIL_RSHIFT(src_w, hsub); \
int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub); int src_hp = AV_CEIL_RSHIFT(src_h, vsub); \
int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub); int dst_wp = AV_CEIL_RSHIFT(dst_w, hsub); \
int yp = y>>vsub; int dst_hp = AV_CEIL_RSHIFT(dst_h, vsub); \
int xp = x>>hsub; int yp = y>>vsub; \
uint8_t *s, *sp, *d, *dp, *dap, *a, *da, *ap; int xp = x>>hsub; \
int jmax, j, k, kmax; uint##depth##_t *s, *sp, *d, *dp, *dap, *a, *da, *ap; \
int slice_start, slice_end; int jmax, j, k, kmax; \
int slice_start, slice_end; \
j = FFMAX(-yp, 0); const uint##depth##_t max = (1 << nbits) - 1; \
jmax = FFMIN3(-yp + dst_hp, FFMIN(src_hp, dst_hp), yp + src_hp); const uint##depth##_t mid = (1 << (nbits -1)) ; \
int bytes = depth / 8; \
slice_start = j + (jmax * jobnr) / nb_jobs; \
slice_end = j + (jmax * (jobnr+1)) / nb_jobs; dst_step /= bytes; \
j = FFMAX(-yp, 0); \
sp = src->data[i] + (slice_start) * src->linesize[i]; jmax = FFMIN3(-yp + dst_hp, FFMIN(src_hp, dst_hp), yp + src_hp); \
dp = dst->data[dst_plane] \
+ (yp + slice_start) * dst->linesize[dst_plane] slice_start = j + (jmax * jobnr) / nb_jobs; \
+ dst_offset; slice_end = j + (jmax * (jobnr+1)) / nb_jobs; \
ap = src->data[3] + (slice_start << vsub) * src->linesize[3]; \
dap = dst->data[3] + ((yp + slice_start) << vsub) * dst->linesize[3]; sp = (uint##depth##_t *)(src->data[i] + (slice_start) * src->linesize[i]); \
dp = (uint##depth##_t *)(dst->data[dst_plane] \
for (j = slice_start; j < slice_end; j++) { + (yp + slice_start) * dst->linesize[dst_plane] \
k = FFMAX(-xp, 0); + dst_offset); \
d = dp + (xp+k) * dst_step; ap = (uint##depth##_t *)(src->data[3] + (slice_start << vsub) * src->linesize[3]); \
s = sp + k; dap = (uint##depth##_t *)(dst->data[3] + ((yp + slice_start) << vsub) * dst->linesize[3]); \
a = ap + (k<<hsub); \
da = dap + ((xp+k) << hsub); for (j = slice_start; j < slice_end; j++) { \
kmax = FFMIN(-xp + dst_wp, src_wp); k = FFMAX(-xp, 0); \
d = dp + (xp+k) * dst_step; \
if (((vsub && j+1 < src_hp) || !vsub) && octx->blend_row[i]) { s = sp + k; \
int c = octx->blend_row[i](d, da, s, a, kmax - k, src->linesize[3]); a = ap + (k<<hsub); \
da = dap + ((xp+k) << hsub); \
s += c; kmax = FFMIN(-xp + dst_wp, src_wp); \
d += dst_step * c; \
da += (1 << hsub) * c; if (nbits == 8 && ((vsub && j+1 < src_hp) || !vsub) && octx->blend_row[i]) { \
a += (1 << hsub) * c; int c = octx->blend_row[i]((uint8_t*)d, (uint8_t*)da, (uint8_t*)s, \
k += c; (uint8_t*)a, kmax - k, src->linesize[3]); \
} \
for (; k < kmax; k++) { s += c; \
int alpha_v, alpha_h, alpha; d += dst_step * c; \
da += (1 << hsub) * c; \
// average alpha for color components, improve quality a += (1 << hsub) * c; \
if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { k += c; \
alpha = (a[0] + a[src->linesize[3]] + } \
a[1] + a[src->linesize[3]+1]) >> 2; for (; k < kmax; k++) { \
} else if (hsub || vsub) { int alpha_v, alpha_h, alpha; \
alpha_h = hsub && k+1 < src_wp ? \
(a[0] + a[1]) >> 1 : a[0]; /* average alpha for color components, improve quality */ \
alpha_v = vsub && j+1 < src_hp ? if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
(a[0] + a[src->linesize[3]]) >> 1 : a[0]; alpha = (a[0] + a[src->linesize[3]] + \
alpha = (alpha_v + alpha_h) >> 1; a[1] + a[src->linesize[3]+1]) >> 2; \
} else } else if (hsub || vsub) { \
alpha = a[0]; alpha_h = hsub && k+1 < src_wp ? \
// if the main channel has an alpha channel, alpha has to be calculated (a[0] + a[1]) >> 1 : a[0]; \
// to create an un-premultiplied (straight) alpha value alpha_v = vsub && j+1 < src_hp ? \
if (main_has_alpha && alpha != 0 && alpha != 255) { (a[0] + a[src->linesize[3]]) >> 1 : a[0]; \
// average alpha for color components, improve quality alpha = (alpha_v + alpha_h) >> 1; \
uint8_t alpha_d; } else \
if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { alpha = a[0]; \
alpha_d = (da[0] + da[dst->linesize[3]] + /* if the main channel has an alpha channel, alpha has to be calculated */ \
da[1] + da[dst->linesize[3]+1]) >> 2; /* to create an un-premultiplied (straight) alpha value */ \
} else if (hsub || vsub) { if (main_has_alpha && alpha != 0 && alpha != max) { \
alpha_h = hsub && k+1 < src_wp ? /* average alpha for color components, improve quality */ \
(da[0] + da[1]) >> 1 : da[0]; uint8_t alpha_d; \
alpha_v = vsub && j+1 < src_hp ? if (hsub && vsub && j+1 < src_hp && k+1 < src_wp) { \
(da[0] + da[dst->linesize[3]]) >> 1 : da[0]; alpha_d = (da[0] + da[dst->linesize[3]] + \
alpha_d = (alpha_v + alpha_h) >> 1; da[1] + da[dst->linesize[3]+1]) >> 2; \
} else } else if (hsub || vsub) { \
alpha_d = da[0]; alpha_h = hsub && k+1 < src_wp ? \
alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); (da[0] + da[1]) >> 1 : da[0]; \
} alpha_v = vsub && j+1 < src_hp ? \
if (straight) { (da[0] + da[dst->linesize[3]]) >> 1 : da[0]; \
*d = FAST_DIV255(*d * (255 - alpha) + *s * alpha); alpha_d = (alpha_v + alpha_h) >> 1; \
} else { } else \
if (i && yuv) alpha_d = da[0]; \
*d = av_clip(FAST_DIV255((*d - 128) * (255 - alpha)) + *s - 128, -128, 128) + 128; alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
else } \
*d = FFMIN(FAST_DIV255(*d * (255 - alpha)) + *s, 255); if (straight) { \
} if (nbits > 8) \
s++; *d = (*d * (max - alpha) + *s * alpha) / max; \
d += dst_step; else \
da += 1 << hsub; *d = FAST_DIV255(*d * (255 - alpha) + *s * alpha); \
a += 1 << hsub; } else { \
} if (nbits > 8) { \
dp += dst->linesize[dst_plane]; if (i && yuv) \
sp += src->linesize[i]; *d = av_clip((*d * (max - alpha) + *s * alpha) / max + *s - mid, -mid, mid) + mid; \
ap += (1 << vsub) * src->linesize[3]; else \
dap += (1 << vsub) * dst->linesize[3]; *d = FFMIN((*d * (max - alpha) + *s * alpha) / max + *s, max); \
} } else { \
if (i && yuv) \
*d = av_clip(FAST_DIV255((*d - mid) * (max - alpha)) + *s - mid, -mid, mid) + mid; \
else \
*d = FFMIN(FAST_DIV255(*d * (max - alpha)) + *s, max); \
} \
} \
s++; \
d += dst_step; \
da += 1 << hsub; \
a += 1 << hsub; \
} \
dp += dst->linesize[dst_plane] / bytes; \
sp += src->linesize[i] / bytes; \
ap += (1 << vsub) * src->linesize[3] / bytes; \
dap += (1 << vsub) * dst->linesize[3] / bytes; \
} \
} }
DEFINE_BLEND_PLANE(8, 8);
static inline void alpha_composite(const AVFrame *src, const AVFrame *dst, #define DEFINE_ALPHA_COMPOSITE(depth, nbits) \
int src_w, int src_h, static inline void alpha_composite_##depth##_##nbits##bits(const AVFrame *src, const AVFrame *dst, \
int dst_w, int dst_h, int src_w, int src_h, \
int x, int y, int dst_w, int dst_h, \
int jobnr, int nb_jobs) int x, int y, \
{ int jobnr, int nb_jobs) \
uint8_t alpha; ///< the amount of overlay to blend on to main { \
uint8_t *s, *sa, *d, *da; uint##depth##_t alpha; /* the amount of overlay to blend on to main */ \
int i, imax, j, jmax; uint##depth##_t *s, *sa, *d, *da; \
int slice_start, slice_end; int i, imax, j, jmax; \
int slice_start, slice_end; \
imax = FFMIN(-y + dst_h, src_h); const uint##depth##_t max = (1 << nbits) - 1; \
slice_start = (imax * jobnr) / nb_jobs; int bytes = depth / 8; \
slice_end = ((imax * (jobnr+1)) / nb_jobs); \
imax = FFMIN(-y + dst_h, src_h); \
i = FFMAX(-y, 0); slice_start = (imax * jobnr) / nb_jobs; \
sa = src->data[3] + (i + slice_start) * src->linesize[3]; slice_end = ((imax * (jobnr+1)) / nb_jobs); \
da = dst->data[3] + (y + i + slice_start) * dst->linesize[3]; \
i = FFMAX(-y, 0); \
for (i = i + slice_start; i < slice_end; i++) { sa = (uint##depth##_t *)(src->data[3] + (i + slice_start) * src->linesize[3]); \
j = FFMAX(-x, 0); da = (uint##depth##_t *)(dst->data[3] + (y + i + slice_start) * dst->linesize[3]); \
s = sa + j; \
d = da + x+j; for (i = i + slice_start; i < slice_end; i++) { \
j = FFMAX(-x, 0); \
for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) { s = sa + j; \
alpha = *s; d = da + x+j; \
if (alpha != 0 && alpha != 255) { \
uint8_t alpha_d = *d; for (jmax = FFMIN(-x + dst_w, src_w); j < jmax; j++) { \
alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); alpha = *s; \
} if (alpha != 0 && alpha != max) { \
switch (alpha) { uint8_t alpha_d = *d; \
case 0: alpha = UNPREMULTIPLY_ALPHA(alpha, alpha_d); \
break; } \
case 255: if (alpha == max) \
*d = *s; *d = *s; \
break; else if (alpha > 0) { \
default: /* apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha */ \
// apply alpha compositing: main_alpha += (1-main_alpha) * overlay_alpha if (nbits > 8) \
*d += FAST_DIV255((255 - *d) * *s); *d += (max - *d) * *s / max; \
} else \
d += 1; *d += FAST_DIV255((max - *d) * *s); \
s += 1; } \
} d += 1; \
da += dst->linesize[3]; s += 1; \
sa += src->linesize[3]; } \
} da += dst->linesize[3] / bytes; \
sa += src->linesize[3] / bytes; \
} \
} }
DEFINE_ALPHA_COMPOSITE(8, 8);
static av_always_inline void blend_slice_yuv(AVFilterContext *ctx, #define DEFINE_BLEND_SLICE_YUV(depth, nbits) \
AVFrame *dst, const AVFrame *src, static av_always_inline void blend_slice_yuv_##depth##_##nbits##bits(AVFilterContext *ctx, \
int hsub, int vsub, AVFrame *dst, const AVFrame *src, \
int main_has_alpha, int hsub, int vsub, \
int x, int y, int main_has_alpha, \
int is_straight, int x, int y, \
int jobnr, int nb_jobs) int is_straight, \
{ int jobnr, int nb_jobs) \
OverlayContext *s = ctx->priv; { \
const int src_w = src->width; OverlayContext *s = ctx->priv; \
const int src_h = src->height; const int src_w = src->width; \
const int dst_w = dst->width; const int src_h = src->height; \
const int dst_h = dst->height; const int dst_w = dst->width; \
const int dst_h = dst->height; \
blend_plane(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, blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, \
jobnr, nb_jobs); x, y, main_has_alpha, s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, \
blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha, s->main_desc->comp[0].step, is_straight, 1, jobnr, nb_jobs); \
s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step, is_straight, 1, blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, \
jobnr, nb_jobs); x, y, main_has_alpha, s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, \
blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha, s->main_desc->comp[1].step, is_straight, 1, jobnr, nb_jobs); \
s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step, is_straight, 1, blend_plane_##depth##_##nbits##bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, \
jobnr, nb_jobs); 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(src, dst, src_w, src_h, dst_w, dst_h, x, y, 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); \
} }
DEFINE_BLEND_SLICE_YUV(8, 8);
static av_always_inline void blend_slice_planar_rgb(AVFilterContext *ctx, static av_always_inline void blend_slice_planar_rgb(AVFilterContext *ctx,
AVFrame *dst, const AVFrame *src, AVFrame *dst, const AVFrame *src,
@ -641,25 +664,25 @@ static av_always_inline void blend_slice_planar_rgb(AVFilterContext *ctx,
const int dst_w = dst->width; const int dst_w = dst->width;
const int dst_h = dst->height; const int dst_h = dst->height;
blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, x, y, main_has_alpha, blend_plane_8_8bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 0, 0, 0, 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, 0, s->main_desc->comp[1].plane, s->main_desc->comp[1].offset, s->main_desc->comp[1].step, is_straight, 0,
jobnr, nb_jobs); jobnr, nb_jobs);
blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, hsub, vsub, x, y, main_has_alpha, blend_plane_8_8bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 1, 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, 0, s->main_desc->comp[2].plane, s->main_desc->comp[2].offset, s->main_desc->comp[2].step, is_straight, 0,
jobnr, nb_jobs); jobnr, nb_jobs);
blend_plane(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, x, y, main_has_alpha, blend_plane_8_8bits(ctx, dst, src, src_w, src_h, dst_w, dst_h, 2, hsub, vsub, 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, 0, s->main_desc->comp[0].plane, s->main_desc->comp[0].offset, s->main_desc->comp[0].step, is_straight, 0,
jobnr, nb_jobs); jobnr, nb_jobs);
if (main_has_alpha) if (main_has_alpha)
alpha_composite(src, dst, src_w, src_h, dst_w, dst_h, x, y, jobnr, nb_jobs); alpha_composite_8_8bits(src, dst, src_w, src_h, dst_w, dst_h, x, y, jobnr, nb_jobs);
} }
static int blend_slice_yuv420(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) static int blend_slice_yuv420(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 1, 0, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 1, 0, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -667,7 +690,7 @@ static int blend_slice_yuva420(AVFilterContext *ctx, void *arg, int jobnr, int n
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 1, 1, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 1, 1, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -675,7 +698,7 @@ static int blend_slice_yuv422(AVFilterContext *ctx, void *arg, int jobnr, int nb
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 0, 0, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 0, 0, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -683,7 +706,7 @@ static int blend_slice_yuva422(AVFilterContext *ctx, void *arg, int jobnr, int n
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 0, 1, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 0, 1, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -691,7 +714,7 @@ static int blend_slice_yuv444(AVFilterContext *ctx, void *arg, int jobnr, int nb
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 0, 0, 0, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 0, 0, 0, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -699,7 +722,7 @@ static int blend_slice_yuva444(AVFilterContext *ctx, void *arg, int jobnr, int n
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 0, 0, 1, s->x, s->y, 1, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 0, 0, 1, s->x, s->y, 1, jobnr, nb_jobs);
return 0; return 0;
} }
@ -723,7 +746,7 @@ static int blend_slice_yuv420_pm(AVFilterContext *ctx, void *arg, int jobnr, int
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 1, 0, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 1, 0, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }
@ -731,7 +754,7 @@ static int blend_slice_yuva420_pm(AVFilterContext *ctx, void *arg, int jobnr, in
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 1, 1, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 1, 1, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }
@ -739,7 +762,7 @@ static int blend_slice_yuv422_pm(AVFilterContext *ctx, void *arg, int jobnr, int
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 0, 0, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 0, 0, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }
@ -747,7 +770,7 @@ static int blend_slice_yuva422_pm(AVFilterContext *ctx, void *arg, int jobnr, in
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 1, 0, 1, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 1, 0, 1, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }
@ -755,7 +778,7 @@ static int blend_slice_yuv444_pm(AVFilterContext *ctx, void *arg, int jobnr, int
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 0, 0, 0, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 0, 0, 0, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }
@ -763,7 +786,7 @@ static int blend_slice_yuva444_pm(AVFilterContext *ctx, void *arg, int jobnr, in
{ {
OverlayContext *s = ctx->priv; OverlayContext *s = ctx->priv;
ThreadData *td = arg; ThreadData *td = arg;
blend_slice_yuv(ctx, td->dst, td->src, 0, 0, 1, s->x, s->y, 0, jobnr, nb_jobs); blend_slice_yuv_8_8bits(ctx, td->dst, td->src, 0, 0, 1, s->x, s->y, 0, jobnr, nb_jobs);
return 0; return 0;
} }