void texture_info::set_coloralphamode(SDL_Texture *texture_id, const render_color *color)
{
UINT32 sr = (UINT32)(255.0f * color->r);
UINT32 sg = (UINT32)(255.0f * color->g);
UINT32 sb = (UINT32)(255.0f * color->b);
UINT32 sa = (UINT32)(255.0f * color->a);
if (color->r >= 1.0f && color->g >= 1.0f && color->b >= 1.0f && is_opaque(color->a))
{
SDL_SetTextureColorMod(texture_id, 0xFF, 0xFF, 0xFF);
SDL_SetTextureAlphaMod(texture_id, 0xFF);
}
/* coloring-only case */
else if (is_opaque(color->a))
{
SDL_SetTextureColorMod(texture_id, sr, sg, sb);
SDL_SetTextureAlphaMod(texture_id, 0xFF);
}
/* alpha and/or coloring case */
else if (!is_transparent(color->a))
{
SDL_SetTextureColorMod(texture_id, sr, sg, sb);
SDL_SetTextureAlphaMod(texture_id, sa);
}
else
{
SDL_SetTextureColorMod(texture_id, 0xFF, 0xFF, 0xFF);
SDL_SetTextureAlphaMod(texture_id, 0x00);
}
}
StateF16(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
: State4f(info, paint, shaderContext)
{
if (is_opaque(paint, shaderContext)) {
fFlags |= SkXfermode::kSrcIsOpaque_F16Flag;
}
SkASSERT(kRGBA_F16_SkColorType == info.colorType());
fProc1 = SkXfermode::GetF16Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_F16Flag);
fProcN = SkXfermode::GetF16Proc(fXfer, fFlags);
}
State32(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
: State4f(info, paint, shaderContext)
{
if (is_opaque(paint, shaderContext)) {
fFlags |= SkXfermode::kSrcIsOpaque_D32Flag;
}
if (info.gammaCloseToSRGB()) {
fFlags |= SkXfermode::kDstIsSRGB_D32Flag;
}
fProc1 = SkXfermode::GetD32Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_D32Flag);
fProcN = SkXfermode::GetD32Proc(fXfer, fFlags);
}
State64(const SkImageInfo& info, const SkPaint& paint, const SkShader::Context* shaderContext)
: State4f(info, paint, shaderContext)
{
if (is_opaque(paint, shaderContext)) {
fFlags |= SkXfermode::kSrcIsOpaque_D64Flag;
}
if (kRGBA_F16_SkColorType == info.colorType()) {
fFlags |= SkXfermode::kDstIsFloat16_D64Flag;
}
fProc1 = SkXfermode::GetD64Proc(fXfer, fFlags | SkXfermode::kSrcIsSingle_D64Flag);
fProcN = SkXfermode::GetD64Proc(fXfer, fFlags);
}
static inline int dissolve_yuv( mlt_frame frame, mlt_frame that, float weight, int width, int height, int threads )
{
int ret = 0;
int i = height + 1;
int width_src = width, height_src = height;
mlt_image_format format = mlt_image_yuv422;
uint8_t *p_src, *p_dest;
uint8_t *alpha_src;
uint8_t *alpha_dst;
int mix = weight * ( 1 << 16 );
if ( mlt_properties_get( &frame->parent, "distort" ) )
mlt_properties_set( &that->parent, "distort", mlt_properties_get( &frame->parent, "distort" ) );
mlt_frame_get_image( frame, &p_dest, &format, &width, &height, 1 );
alpha_dst = mlt_frame_get_alpha_mask( frame );
mlt_frame_get_image( that, &p_src, &format, &width_src, &height_src, 0 );
alpha_src = mlt_frame_get_alpha_mask( that );
int is_translucent = ( alpha_dst && !is_opaque(alpha_dst, width, height) )
|| ( alpha_src && !is_opaque(alpha_src, width_src, height_src) );
// Pick the lesser of two evils ;-)
width_src = width_src > width ? width : width_src;
height_src = height_src > height ? height : height_src;
if (is_translucent)
{
struct dissolve_slice_context context = {
.dst_image = p_dest,
.src_image = p_src,
.dst_alpha = alpha_dst,
.src_alpha = alpha_src,
.width = width_src,
.height = height_src,
.weight = weight
};
mlt_slices_run_normal(threads, dissolve_slice, &context);
}
else
{
while ( --i )
static int fast_op(struct fimg2d_bltcmd *cmd)
{
int sa, da, ga;
int fop = cmd->op;
struct fimg2d_image *src, *msk, *dst;
struct fimg2d_param *p = &cmd->param;
src = &cmd->image[ISRC];
msk = &cmd->image[IMSK];
dst = &cmd->image[IDST];
if (msk->addr.type)
return fop;
ga = p->g_alpha;
da = is_opaque(dst->fmt) ? 0xff : 0;
if (!src->addr.type)
sa = (p->solid_color >> 24) & 0xff;
else
{
int sa, da, ga;
int fop = cmd->op;
struct fimg2d_image *sm, *dm;
struct fimg2d_param *p = &cmd->param;
if (cmd->image[IMSK].addr.type != ADDR_NONE)
return fop;
sm = &cmd->image[ISRC];
dm = &cmd->image[IDST];
if (sm->addr.type == ADDR_NONE)
sa = (p->solid_color >> 24) & 0xff;
else
sa = is_opaque(sm->fmt) ? 0xff : 0;
da = is_opaque(dm->fmt) ? 0xff : 0;
ga = p->g_alpha;
switch (cmd->op) {
case BLIT_OP_SOLID_FILL:
case BLIT_OP_CLR:
case BLIT_OP_SRC:
case BLIT_OP_DST:
break;
case BLIT_OP_SRC_OVER:
/* Sc + (1-Sa)*Dc = Sc */
if (sa == 0xff && ga == 0xff)
fop = BLIT_OP_SRC;
break;
src = &cmd->image[ISRC];
msk = &cmd->image[IMSK];
dst = &cmd->image[IDST];
fop = cmd->blt.op;
if (msk->addr.type)
return fop;
ga = p->g_alpha;
da = is_opaque(dst->fmt) ? 0xff : 0;
if (!src->addr.type)
sa = (p->solid_color >> 24) & 0xff;
else
sa = is_opaque(src->fmt) ? 0xff : 0;
switch (cmd->blt.op) {
case BLIT_OP_SRC_OVER:
/* Sc + (1-Sa)*Dc = Sc */
if (sa == 0xff && ga == 0xff)
fop = BLIT_OP_SRC;
break;
case BLIT_OP_DST_OVER:
/* (1-Da)*Sc + Dc = Dc */
if (da == 0xff)
fop = BLIT_OP_DST; /* nop */
break;
case BLIT_OP_SRC_IN:
/* Da*Sc = Sc */
if (da == 0xff)
