| #include "xorg_composite.h" |
| |
| #include "xorg_renderer.h" |
| #include "xorg_exa_tgsi.h" |
| |
| #include "cso_cache/cso_context.h" |
| #include "util/u_format.h" |
| #include "util/u_sampler.h" |
| |
| |
| /*XXX also in Xrender.h but the including it here breaks compilition */ |
| #define XFixedToDouble(f) (((double) (f)) / 65536.) |
| |
| struct xorg_composite_blend { |
| int op : 8; |
| |
| unsigned alpha_dst : 4; |
| unsigned alpha_src : 4; |
| |
| unsigned rgb_src : 8; /**< PIPE_BLENDFACTOR_x */ |
| unsigned rgb_dst : 8; /**< PIPE_BLENDFACTOR_x */ |
| }; |
| |
| #define BLEND_OP_OVER 3 |
| static const struct xorg_composite_blend xorg_blends[] = { |
| { PictOpClear, |
| 0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ZERO}, |
| { PictOpSrc, |
| 0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ZERO}, |
| { PictOpDst, |
| 0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ONE}, |
| { PictOpOver, |
| 0, 1, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_INV_SRC_ALPHA}, |
| { PictOpOverReverse, |
| 1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ONE}, |
| { PictOpIn, |
| 1, 0, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_ZERO}, |
| { PictOpInReverse, |
| 0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_SRC_ALPHA}, |
| { PictOpOut, |
| 1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ZERO}, |
| { PictOpOutReverse, |
| 0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_INV_SRC_ALPHA}, |
| { PictOpAtop, |
| 1, 1, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA}, |
| { PictOpAtopReverse, |
| 1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_SRC_ALPHA}, |
| { PictOpXor, |
| 1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA}, |
| { PictOpAdd, |
| 0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ONE}, |
| }; |
| |
| |
| static INLINE void |
| pixel_to_float4(Pixel pixel, float *color, enum pipe_format format) |
| { |
| const struct util_format_description *format_desc; |
| uint8_t packed[4]; |
| |
| format_desc = util_format_description(format); |
| packed[0] = pixel; |
| packed[1] = pixel >> 8; |
| packed[2] = pixel >> 16; |
| packed[3] = pixel >> 24; |
| format_desc->unpack_rgba_float(color, 0, packed, 0, 1, 1); |
| } |
| |
| static boolean |
| blend_for_op(struct xorg_composite_blend *blend, |
| int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture, |
| PicturePtr pDstPicture) |
| { |
| const int num_blends = |
| sizeof(xorg_blends)/sizeof(struct xorg_composite_blend); |
| int i; |
| boolean supported = FALSE; |
| |
| /* our default in case something goes wrong */ |
| *blend = xorg_blends[BLEND_OP_OVER]; |
| |
| for (i = 0; i < num_blends; ++i) { |
| if (xorg_blends[i].op == op) { |
| *blend = xorg_blends[i]; |
| supported = TRUE; |
| } |
| } |
| |
| /* If there's no dst alpha channel, adjust the blend op so that we'll treat |
| * it as always 1. */ |
| if (pDstPicture && |
| PICT_FORMAT_A(pDstPicture->format) == 0 && blend->alpha_dst) { |
| if (blend->rgb_src == PIPE_BLENDFACTOR_DST_ALPHA) |
| blend->rgb_src = PIPE_BLENDFACTOR_ONE; |
| else if (blend->rgb_src == PIPE_BLENDFACTOR_INV_DST_ALPHA) |
| blend->rgb_src = PIPE_BLENDFACTOR_ZERO; |
| } |
| |
| /* If the source alpha is being used, then we should only be in a case where |
| * the source blend factor is 0, and the source blend value is the mask |
| * channels multiplied by the source picture's alpha. */ |
| if (pMaskPicture && pMaskPicture->componentAlpha && |
| PICT_FORMAT_RGB(pMaskPicture->format) && blend->alpha_src) { |
| if (blend->rgb_dst == PIPE_BLENDFACTOR_SRC_ALPHA) { |
| blend->rgb_dst = PIPE_BLENDFACTOR_SRC_COLOR; |
| } else if (blend->rgb_dst == PIPE_BLENDFACTOR_INV_SRC_ALPHA) { |
| blend->rgb_dst = PIPE_BLENDFACTOR_INV_SRC_COLOR; |
| } |
| } |
| |
| return supported; |
| } |
| |
| static INLINE int |
| render_repeat_to_gallium(int mode) |
| { |
| switch(mode) { |
| case RepeatNone: |
| return PIPE_TEX_WRAP_CLAMP_TO_BORDER; |
| case RepeatNormal: |
| return PIPE_TEX_WRAP_REPEAT; |
| case RepeatReflect: |
| return PIPE_TEX_WRAP_MIRROR_REPEAT; |
| case RepeatPad: |
| return PIPE_TEX_WRAP_CLAMP_TO_EDGE; |
| default: |
| debug_printf("Unsupported repeat mode\n"); |
| } |
| return PIPE_TEX_WRAP_REPEAT; |
| } |
| |
| static INLINE boolean |
| render_filter_to_gallium(int xrender_filter, int *out_filter) |
| { |
| |
| switch (xrender_filter) { |
| case PictFilterNearest: |
| *out_filter = PIPE_TEX_FILTER_NEAREST; |
| break; |
| case PictFilterBilinear: |
| *out_filter = PIPE_TEX_FILTER_LINEAR; |
| break; |
| case PictFilterFast: |
| *out_filter = PIPE_TEX_FILTER_NEAREST; |
| break; |
| case PictFilterGood: |
| *out_filter = PIPE_TEX_FILTER_LINEAR; |
| break; |
| case PictFilterBest: |
| *out_filter = PIPE_TEX_FILTER_LINEAR; |
| break; |
| case PictFilterConvolution: |
| *out_filter = PIPE_TEX_FILTER_NEAREST; |
| return FALSE; |
| default: |
| debug_printf("Unknown xrender filter\n"); |
| *out_filter = PIPE_TEX_FILTER_NEAREST; |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| static boolean is_filter_accelerated(PicturePtr pic) |
| { |
| int filter; |
| if (pic && !render_filter_to_gallium(pic->filter, &filter)) |
| return FALSE; |
| return TRUE; |
| } |
| |
| boolean xorg_composite_accelerated(int op, |
| PicturePtr pSrcPicture, |
| PicturePtr pMaskPicture, |
| PicturePtr pDstPicture) |
| { |
| ScreenPtr pScreen = pDstPicture->pDrawable->pScreen; |
| ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); |
| modesettingPtr ms = modesettingPTR(pScrn); |
| struct xorg_composite_blend blend; |
| |
| if (!is_filter_accelerated(pSrcPicture) || |
| !is_filter_accelerated(pMaskPicture)) { |
| XORG_FALLBACK("Unsupported Xrender filter"); |
| } |
| |
| if (pSrcPicture->pSourcePict) { |
| if (pSrcPicture->pSourcePict->type != SourcePictTypeSolidFill) |
| XORG_FALLBACK("Gradients not enabled (haven't been well tested)"); |
| } |
| |
| if (blend_for_op(&blend, op, |
| pSrcPicture, pMaskPicture, pDstPicture)) { |
| /* Check for component alpha */ |
| if (pMaskPicture && pMaskPicture->componentAlpha && |
| PICT_FORMAT_RGB(pMaskPicture->format)) { |
| if (blend.alpha_src && blend.rgb_src != PIPE_BLENDFACTOR_ZERO) { |
| XORG_FALLBACK("Component alpha not supported with source " |
| "alpha and source value blending. (op=%d)", |
| op); |
| } |
| } |
| |
| return TRUE; |
| } |
| XORG_FALLBACK("Unsupported composition operation = %d", op); |
| } |
| |
| static void |
| bind_blend_state(struct exa_context *exa, int op, |
| PicturePtr pSrcPicture, |
| PicturePtr pMaskPicture, |
| PicturePtr pDstPicture) |
| { |
| struct xorg_composite_blend blend_opt; |
| struct pipe_blend_state blend; |
| |
| blend_for_op(&blend_opt, op, pSrcPicture, pMaskPicture, pDstPicture); |
| |
| memset(&blend, 0, sizeof(struct pipe_blend_state)); |
| blend.rt[0].blend_enable = 1; |
| blend.rt[0].colormask = PIPE_MASK_RGBA; |
| |
| blend.rt[0].rgb_src_factor = blend_opt.rgb_src; |
| blend.rt[0].alpha_src_factor = blend_opt.rgb_src; |
| blend.rt[0].rgb_dst_factor = blend_opt.rgb_dst; |
| blend.rt[0].alpha_dst_factor = blend_opt.rgb_dst; |
| |
| cso_set_blend(exa->renderer->cso, &blend); |
| } |
| |
| static unsigned |
| picture_format_fixups(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture, boolean mask, |
| PicturePtr pDstPicture) |
| { |
| boolean set_alpha = FALSE; |
| boolean swizzle = FALSE; |
| unsigned ret = 0; |
| |
| if (pSrc && pSrc->picture_format == pSrcPicture->format) { |
| if (pSrc->picture_format == PICT_a8) { |
| if (mask) |
| return FS_MASK_LUMINANCE; |
| else if (pDstPicture->format != PICT_a8) { |
| /* if both dst and src are luminance then |
| * we don't want to swizzle the alpha (X) of the |
| * source into W component of the dst because |
| * it will break our destination */ |
| return FS_SRC_LUMINANCE; |
| } |
| } |
| return 0; |
| } |
| |
| if (pSrc && pSrc->picture_format != PICT_a8r8g8b8) { |
| assert(!"can not handle formats"); |
| return 0; |
| } |
| |
| /* pSrc->picture_format == PICT_a8r8g8b8 */ |
| switch (pSrcPicture->format) { |
| case PICT_x8b8g8r8: |
| case PICT_b8g8r8: |
| set_alpha = TRUE; /* fall trough */ |
| case PICT_a8b8g8r8: |
| swizzle = TRUE; |
| break; |
| case PICT_x8r8g8b8: |
| case PICT_r8g8b8: |
| set_alpha = TRUE; /* fall through */ |
| case PICT_a8r8g8b8: |
| break; |
| #ifdef PICT_TYPE_BGRA |
| case PICT_b8g8r8a8: |
| case PICT_b8g8r8x8: |
| case PICT_a2r10g10b10: |
| case PICT_x2r10g10b10: |
| case PICT_a2b10g10r10: |
| case PICT_x2b10g10r10: |
| #endif |
| default: |
| assert(!"can not handle formats"); |
| return 0; |
| } |
| |
| if (set_alpha) |
| ret |= mask ? FS_MASK_SET_ALPHA : FS_SRC_SET_ALPHA; |
| if (swizzle) |
| ret |= mask ? FS_MASK_SWIZZLE_RGB : FS_SRC_SWIZZLE_RGB; |
| |
| return ret; |
| } |
| |
| static void |
| bind_shaders(struct exa_context *exa, int op, |
| PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture, |
| struct exa_pixmap_priv *pSrc, struct exa_pixmap_priv *pMask) |
| { |
| unsigned vs_traits = 0, fs_traits = 0; |
| struct xorg_shader shader; |
| |
| exa->has_solid_color = FALSE; |
| |
| if (pSrcPicture) { |
| if (pSrcPicture->repeatType == RepeatNone && pSrcPicture->transform) |
| fs_traits |= FS_SRC_REPEAT_NONE; |
| |
| if (pSrcPicture->pSourcePict) { |
| if (pSrcPicture->pSourcePict->type == SourcePictTypeSolidFill) { |
| fs_traits |= FS_SOLID_FILL; |
| vs_traits |= VS_SOLID_FILL; |
| debug_assert(pSrcPicture->format == PICT_a8r8g8b8); |
| pixel_to_float4(pSrcPicture->pSourcePict->solidFill.color, |
| exa->solid_color, PIPE_FORMAT_B8G8R8A8_UNORM); |
| exa->has_solid_color = TRUE; |
| } else { |
| debug_assert("!gradients not supported"); |
| } |
| } else { |
| fs_traits |= FS_COMPOSITE; |
| vs_traits |= VS_COMPOSITE; |
| } |
| |
| fs_traits |= picture_format_fixups(pSrc, pSrcPicture, FALSE, pDstPicture); |
| } |
| |
| if (pMaskPicture) { |
| vs_traits |= VS_MASK; |
| fs_traits |= FS_MASK; |
| if (pMaskPicture->repeatType == RepeatNone && pMaskPicture->transform) |
| fs_traits |= FS_MASK_REPEAT_NONE; |
| if (pMaskPicture->componentAlpha) { |
| struct xorg_composite_blend blend; |
| blend_for_op(&blend, op, |
| pSrcPicture, pMaskPicture, NULL); |
| if (blend.alpha_src) { |
| fs_traits |= FS_CA_SRCALPHA; |
| } else |
| fs_traits |= FS_CA_FULL; |
| } |
| |
| fs_traits |= picture_format_fixups(pMask, pMaskPicture, TRUE, pDstPicture); |
| } |
| |
| shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits); |
| cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs); |
| cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs); |
| } |
| |
| static void |
| bind_samplers(struct exa_context *exa, int op, |
| PicturePtr pSrcPicture, PicturePtr pMaskPicture, |
| PicturePtr pDstPicture, |
| struct exa_pixmap_priv *pSrc, |
| struct exa_pixmap_priv *pMask, |
| struct exa_pixmap_priv *pDst) |
| { |
| struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS] = {0}; |
| struct pipe_sampler_state src_sampler, mask_sampler; |
| struct pipe_sampler_view view_templ; |
| struct pipe_sampler_view *src_view; |
| struct pipe_context *pipe = exa->pipe; |
| |
| exa->num_bound_samplers = 0; |
| |
| memset(&src_sampler, 0, sizeof(struct pipe_sampler_state)); |
| memset(&mask_sampler, 0, sizeof(struct pipe_sampler_state)); |
| |
| if (pSrcPicture && pSrc) { |
| if (exa->has_solid_color) { |
| debug_assert(!"solid color with textures"); |
| samplers[0] = NULL; |
| pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL); |
| } else { |
| unsigned src_wrap = render_repeat_to_gallium( |
| pSrcPicture->repeatType); |
| int filter; |
| |
| render_filter_to_gallium(pSrcPicture->filter, &filter); |
| |
| src_sampler.wrap_s = src_wrap; |
| src_sampler.wrap_t = src_wrap; |
| src_sampler.min_img_filter = filter; |
| src_sampler.mag_img_filter = filter; |
| src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST; |
| src_sampler.normalized_coords = 1; |
| samplers[0] = &src_sampler; |
| exa->num_bound_samplers = 1; |
| u_sampler_view_default_template(&view_templ, |
| pSrc->tex, |
| pSrc->tex->format); |
| src_view = pipe->create_sampler_view(pipe, pSrc->tex, &view_templ); |
| pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL); |
| exa->bound_sampler_views[0] = src_view; |
| } |
| } |
| |
| if (pMaskPicture && pMask) { |
| unsigned mask_wrap = render_repeat_to_gallium( |
| pMaskPicture->repeatType); |
| int filter; |
| |
| render_filter_to_gallium(pMaskPicture->filter, &filter); |
| |
| mask_sampler.wrap_s = mask_wrap; |
| mask_sampler.wrap_t = mask_wrap; |
| mask_sampler.min_img_filter = filter; |
| mask_sampler.mag_img_filter = filter; |
| src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST; |
| mask_sampler.normalized_coords = 1; |
| samplers[1] = &mask_sampler; |
| exa->num_bound_samplers = 2; |
| u_sampler_view_default_template(&view_templ, |
| pMask->tex, |
| pMask->tex->format); |
| src_view = pipe->create_sampler_view(pipe, pMask->tex, &view_templ); |
| pipe_sampler_view_reference(&exa->bound_sampler_views[1], NULL); |
| exa->bound_sampler_views[1] = src_view; |
| } |
| |
| cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT, |
| exa->num_bound_samplers, |
| (const struct pipe_sampler_state **)samplers); |
| cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT, |
| exa->num_bound_samplers, |
| exa->bound_sampler_views); |
| } |
| |
| |
| |
| static INLINE boolean matrix_from_pict_transform(PictTransform *trans, float *matrix) |
| { |
| if (!trans) |
| return FALSE; |
| |
| matrix[0] = XFixedToDouble(trans->matrix[0][0]); |
| matrix[3] = XFixedToDouble(trans->matrix[0][1]); |
| matrix[6] = XFixedToDouble(trans->matrix[0][2]); |
| |
| matrix[1] = XFixedToDouble(trans->matrix[1][0]); |
| matrix[4] = XFixedToDouble(trans->matrix[1][1]); |
| matrix[7] = XFixedToDouble(trans->matrix[1][2]); |
| |
| matrix[2] = XFixedToDouble(trans->matrix[2][0]); |
| matrix[5] = XFixedToDouble(trans->matrix[2][1]); |
| matrix[8] = XFixedToDouble(trans->matrix[2][2]); |
| |
| return TRUE; |
| } |
| |
| static void |
| setup_transforms(struct exa_context *exa, |
| PicturePtr pSrcPicture, PicturePtr pMaskPicture) |
| { |
| PictTransform *src_t = NULL; |
| PictTransform *mask_t = NULL; |
| |
| if (pSrcPicture) |
| src_t = pSrcPicture->transform; |
| if (pMaskPicture) |
| mask_t = pMaskPicture->transform; |
| |
| exa->transform.has_src = |
| matrix_from_pict_transform(src_t, exa->transform.src); |
| exa->transform.has_mask = |
| matrix_from_pict_transform(mask_t, exa->transform.mask); |
| } |
| |
| boolean xorg_composite_bind_state(struct exa_context *exa, |
| int op, |
| PicturePtr pSrcPicture, |
| PicturePtr pMaskPicture, |
| PicturePtr pDstPicture, |
| struct exa_pixmap_priv *pSrc, |
| struct exa_pixmap_priv *pMask, |
| struct exa_pixmap_priv *pDst) |
| { |
| struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pDst); |
| |
| renderer_bind_destination(exa->renderer, dst_surf, |
| pDst->width, |
| pDst->height); |
| |
| bind_blend_state(exa, op, pSrcPicture, pMaskPicture, pDstPicture); |
| bind_shaders(exa, op, pSrcPicture, pMaskPicture, pDstPicture, pSrc, pMask); |
| bind_samplers(exa, op, pSrcPicture, pMaskPicture, |
| pDstPicture, pSrc, pMask, pDst); |
| |
| setup_transforms(exa, pSrcPicture, pMaskPicture); |
| |
| if (exa->num_bound_samplers == 0 ) { /* solid fill */ |
| renderer_begin_solid(exa->renderer); |
| } else { |
| renderer_begin_textures(exa->renderer, |
| exa->num_bound_samplers); |
| } |
| |
| |
| pipe_surface_reference(&dst_surf, NULL); |
| return TRUE; |
| } |
| |
| void xorg_composite(struct exa_context *exa, |
| struct exa_pixmap_priv *dst, |
| int srcX, int srcY, int maskX, int maskY, |
| int dstX, int dstY, int width, int height) |
| { |
| if (exa->num_bound_samplers == 0 ) { /* solid fill */ |
| renderer_solid(exa->renderer, |
| dstX, dstY, dstX + width, dstY + height, |
| exa->solid_color); |
| } else { |
| int pos[6] = {srcX, srcY, maskX, maskY, dstX, dstY}; |
| float *src_matrix = NULL; |
| float *mask_matrix = NULL; |
| |
| if (exa->transform.has_src) |
| src_matrix = exa->transform.src; |
| if (exa->transform.has_mask) |
| mask_matrix = exa->transform.mask; |
| |
| renderer_texture(exa->renderer, |
| pos, width, height, |
| exa->bound_sampler_views, |
| exa->num_bound_samplers, |
| src_matrix, mask_matrix); |
| } |
| } |
| |
| boolean xorg_solid_bind_state(struct exa_context *exa, |
| struct exa_pixmap_priv *pixmap, |
| Pixel fg) |
| { |
| struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pixmap); |
| unsigned vs_traits, fs_traits; |
| struct xorg_shader shader; |
| |
| pixel_to_float4(fg, exa->solid_color, pixmap->tex->format); |
| exa->has_solid_color = TRUE; |
| |
| #if 0 |
| debug_printf("Color Pixel=(%d, %d, %d, %d), RGBA=(%f, %f, %f, %f)\n", |
| (fg >> 24) & 0xff, (fg >> 16) & 0xff, |
| (fg >> 8) & 0xff, (fg >> 0) & 0xff, |
| exa->solid_color[0], exa->solid_color[1], |
| exa->solid_color[2], exa->solid_color[3]); |
| #endif |
| |
| vs_traits = VS_SOLID_FILL; |
| fs_traits = FS_SOLID_FILL; |
| |
| renderer_bind_destination(exa->renderer, dst_surf, |
| pixmap->width, pixmap->height); |
| bind_blend_state(exa, PictOpSrc, NULL, NULL, NULL); |
| cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL); |
| cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL); |
| |
| shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits); |
| cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs); |
| cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs); |
| |
| renderer_begin_solid(exa->renderer); |
| |
| pipe_surface_reference(&dst_surf, NULL); |
| return TRUE; |
| } |
| |
| void xorg_solid(struct exa_context *exa, |
| struct exa_pixmap_priv *pixmap, |
| int x0, int y0, int x1, int y1) |
| { |
| renderer_solid(exa->renderer, |
| x0, y0, x1, y1, exa->solid_color); |
| } |
| |
| void |
| xorg_composite_done(struct exa_context *exa) |
| { |
| renderer_draw_flush(exa->renderer); |
| |
| exa->transform.has_src = FALSE; |
| exa->transform.has_mask = FALSE; |
| exa->has_solid_color = FALSE; |
| exa->num_bound_samplers = 0; |
| } |
