Home | History | Annotate | Download | only in xorg 
      1 #include "xorg_composite.h"
      2 
      3 #include "xorg_renderer.h"
      4 #include "xorg_exa_tgsi.h"
      5 
      6 #include "cso_cache/cso_context.h"
      7 #include "util/u_format.h"
      8 #include "util/u_sampler.h"
      9 
     10 
     11 /*XXX also in Xrender.h but the including it here breaks compilition */
     12 #define XFixedToDouble(f)    (((double) (f)) / 65536.)
     13 
     14 struct xorg_composite_blend {
     15    int op : 8;
     16 
     17    unsigned alpha_dst : 4;
     18    unsigned alpha_src : 4;
     19 
     20    unsigned rgb_src : 8;    /**< PIPE_BLENDFACTOR_x */
     21    unsigned rgb_dst : 8;    /**< PIPE_BLENDFACTOR_x */
     22 };
     23 
     24 #define BLEND_OP_OVER 3
     25 static const struct xorg_composite_blend xorg_blends[] = {
     26    { PictOpClear,
     27      0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ZERO},
     28    { PictOpSrc,
     29      0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ZERO},
     30    { PictOpDst,
     31      0, 0, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_ONE},
     32    { PictOpOver,
     33      0, 1, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
     34    { PictOpOverReverse,
     35      1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ONE},
     36    { PictOpIn,
     37      1, 0, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_ZERO},
     38    { PictOpInReverse,
     39      0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_SRC_ALPHA},
     40    { PictOpOut,
     41      1, 0, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_ZERO},
     42    { PictOpOutReverse,
     43      0, 1, PIPE_BLENDFACTOR_ZERO, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
     44    { PictOpAtop,
     45      1, 1, PIPE_BLENDFACTOR_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
     46    { PictOpAtopReverse,
     47      1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_SRC_ALPHA},
     48    { PictOpXor,
     49      1, 1, PIPE_BLENDFACTOR_INV_DST_ALPHA, PIPE_BLENDFACTOR_INV_SRC_ALPHA},
     50    { PictOpAdd,
     51      0, 0, PIPE_BLENDFACTOR_ONE, PIPE_BLENDFACTOR_ONE},
     52 };
     53 
     54 
     55 static INLINE void
     56 pixel_to_float4(Pixel pixel, float *color, enum pipe_format format)
     57 {
     58    const struct util_format_description *format_desc;
     59    uint8_t packed[4];
     60 
     61    format_desc = util_format_description(format);
     62    packed[0] = pixel;
     63    packed[1] = pixel >> 8;
     64    packed[2] = pixel >> 16;
     65    packed[3] = pixel >> 24;
     66    format_desc->unpack_rgba_float(color, 0, packed, 0, 1, 1);
     67 }
     68 
     69 static boolean
     70 blend_for_op(struct xorg_composite_blend *blend,
     71              int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture,
     72              PicturePtr pDstPicture)
     73 {
     74    const int num_blends =
     75       sizeof(xorg_blends)/sizeof(struct xorg_composite_blend);
     76    int i;
     77    boolean supported = FALSE;
     78 
     79    /* our default in case something goes wrong */
     80    *blend = xorg_blends[BLEND_OP_OVER];
     81 
     82    for (i = 0; i < num_blends; ++i) {
     83       if (xorg_blends[i].op == op) {
     84          *blend = xorg_blends[i];
     85          supported = TRUE;
     86       }
     87    }
     88 
     89    /* If there's no dst alpha channel, adjust the blend op so that we'll treat
     90     * it as always 1. */
     91    if (pDstPicture &&
     92        PICT_FORMAT_A(pDstPicture->format) == 0 && blend->alpha_dst) {
     93       if (blend->rgb_src == PIPE_BLENDFACTOR_DST_ALPHA)
     94          blend->rgb_src = PIPE_BLENDFACTOR_ONE;
     95       else if (blend->rgb_src == PIPE_BLENDFACTOR_INV_DST_ALPHA)
     96          blend->rgb_src = PIPE_BLENDFACTOR_ZERO;
     97    }
     98 
     99    /* If the source alpha is being used, then we should only be in a case where
    100     * the source blend factor is 0, and the source blend value is the mask
    101     * channels multiplied by the source picture's alpha. */
    102    if (pMaskPicture && pMaskPicture->componentAlpha &&
    103        PICT_FORMAT_RGB(pMaskPicture->format) && blend->alpha_src) {
    104       if (blend->rgb_dst == PIPE_BLENDFACTOR_SRC_ALPHA) {
    105          blend->rgb_dst = PIPE_BLENDFACTOR_SRC_COLOR;
    106       } else if (blend->rgb_dst == PIPE_BLENDFACTOR_INV_SRC_ALPHA) {
    107          blend->rgb_dst = PIPE_BLENDFACTOR_INV_SRC_COLOR;
    108       }
    109    }
    110 
    111    return supported;
    112 }
    113 
    114 static INLINE int
    115 render_repeat_to_gallium(int mode)
    116 {
    117    switch(mode) {
    118    case RepeatNone:
    119       return PIPE_TEX_WRAP_CLAMP_TO_BORDER;
    120    case RepeatNormal:
    121       return PIPE_TEX_WRAP_REPEAT;
    122    case RepeatReflect:
    123       return PIPE_TEX_WRAP_MIRROR_REPEAT;
    124    case RepeatPad:
    125       return PIPE_TEX_WRAP_CLAMP_TO_EDGE;
    126    default:
    127       debug_printf("Unsupported repeat mode\n");
    128    }
    129    return PIPE_TEX_WRAP_REPEAT;
    130 }
    131 
    132 static INLINE boolean
    133 render_filter_to_gallium(int xrender_filter, int *out_filter)
    134 {
    135 
    136    switch (xrender_filter) {
    137    case PictFilterNearest:
    138       *out_filter = PIPE_TEX_FILTER_NEAREST;
    139       break;
    140    case PictFilterBilinear:
    141       *out_filter = PIPE_TEX_FILTER_LINEAR;
    142       break;
    143    case PictFilterFast:
    144       *out_filter = PIPE_TEX_FILTER_NEAREST;
    145       break;
    146    case PictFilterGood:
    147       *out_filter = PIPE_TEX_FILTER_LINEAR;
    148       break;
    149    case PictFilterBest:
    150       *out_filter = PIPE_TEX_FILTER_LINEAR;
    151       break;
    152    case PictFilterConvolution:
    153       *out_filter = PIPE_TEX_FILTER_NEAREST;
    154       return FALSE;
    155    default:
    156       debug_printf("Unknown xrender filter\n");
    157       *out_filter = PIPE_TEX_FILTER_NEAREST;
    158       return FALSE;
    159    }
    160 
    161    return TRUE;
    162 }
    163 
    164 static boolean is_filter_accelerated(PicturePtr pic)
    165 {
    166    int filter;
    167    if (pic && !render_filter_to_gallium(pic->filter, &filter))
    168        return FALSE;
    169    return TRUE;
    170 }
    171 
    172 boolean xorg_composite_accelerated(int op,
    173                                    PicturePtr pSrcPicture,
    174                                    PicturePtr pMaskPicture,
    175                                    PicturePtr pDstPicture)
    176 {
    177    ScreenPtr pScreen = pDstPicture->pDrawable->pScreen;
    178    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
    179    modesettingPtr ms = modesettingPTR(pScrn);
    180    struct xorg_composite_blend blend;
    181 
    182    if (!is_filter_accelerated(pSrcPicture) ||
    183        !is_filter_accelerated(pMaskPicture)) {
    184       XORG_FALLBACK("Unsupported Xrender filter");
    185    }
    186 
    187    if (pSrcPicture->pSourcePict) {
    188       if (pSrcPicture->pSourcePict->type != SourcePictTypeSolidFill)
    189          XORG_FALLBACK("Gradients not enabled (haven't been well tested)");
    190    }
    191 
    192    if (blend_for_op(&blend, op,
    193                     pSrcPicture, pMaskPicture, pDstPicture)) {
    194       /* Check for component alpha */
    195       if (pMaskPicture && pMaskPicture->componentAlpha &&
    196           PICT_FORMAT_RGB(pMaskPicture->format)) {
    197          if (blend.alpha_src && blend.rgb_src != PIPE_BLENDFACTOR_ZERO) {
    198             XORG_FALLBACK("Component alpha not supported with source "
    199                           "alpha and source value blending. (op=%d)",
    200                           op);
    201          }
    202       }
    203 
    204       return TRUE;
    205    }
    206    XORG_FALLBACK("Unsupported composition operation = %d", op);
    207 }
    208 
    209 static void
    210 bind_blend_state(struct exa_context *exa, int op,
    211                  PicturePtr pSrcPicture,
    212                  PicturePtr pMaskPicture,
    213                  PicturePtr pDstPicture)
    214 {
    215    struct xorg_composite_blend blend_opt;
    216    struct pipe_blend_state blend;
    217 
    218    blend_for_op(&blend_opt, op, pSrcPicture, pMaskPicture, pDstPicture);
    219 
    220    memset(&blend, 0, sizeof(struct pipe_blend_state));
    221    blend.rt[0].blend_enable = 1;
    222    blend.rt[0].colormask = PIPE_MASK_RGBA;
    223 
    224    blend.rt[0].rgb_src_factor   = blend_opt.rgb_src;
    225    blend.rt[0].alpha_src_factor = blend_opt.rgb_src;
    226    blend.rt[0].rgb_dst_factor   = blend_opt.rgb_dst;
    227    blend.rt[0].alpha_dst_factor = blend_opt.rgb_dst;
    228 
    229    cso_set_blend(exa->renderer->cso, &blend);
    230 }
    231 
    232 static unsigned
    233 picture_format_fixups(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture, boolean mask,
    234                       PicturePtr pDstPicture)
    235 {
    236    boolean set_alpha = FALSE;
    237    boolean swizzle = FALSE;
    238    unsigned ret = 0;
    239 
    240    if (pSrc && pSrc->picture_format == pSrcPicture->format) {
    241       if (pSrc->picture_format == PICT_a8) {
    242          if (mask)
    243             return FS_MASK_LUMINANCE;
    244          else if (pDstPicture->format != PICT_a8) {
    245             /* if both dst and src are luminance then
    246              * we don't want to swizzle the alpha (X) of the
    247              * source into W component of the dst because
    248              * it will break our destination */
    249             return FS_SRC_LUMINANCE;
    250          }
    251       }
    252       return 0;
    253    }
    254 
    255    if (pSrc && pSrc->picture_format != PICT_a8r8g8b8) {
    256       assert(!"can not handle formats");
    257       return 0;
    258    }
    259 
    260    /* pSrc->picture_format == PICT_a8r8g8b8 */
    261    switch (pSrcPicture->format) {
    262    case PICT_x8b8g8r8:
    263    case PICT_b8g8r8:
    264       set_alpha = TRUE; /* fall trough */
    265    case PICT_a8b8g8r8:
    266       swizzle = TRUE;
    267       break;
    268    case PICT_x8r8g8b8:
    269    case PICT_r8g8b8:
    270       set_alpha = TRUE; /* fall through */
    271    case PICT_a8r8g8b8:
    272       break;
    273 #ifdef PICT_TYPE_BGRA
    274    case PICT_b8g8r8a8:
    275    case PICT_b8g8r8x8:
    276    case PICT_a2r10g10b10:
    277    case PICT_x2r10g10b10:
    278    case PICT_a2b10g10r10:
    279    case PICT_x2b10g10r10:
    280 #endif
    281    default:
    282       assert(!"can not handle formats");
    283       return 0;
    284    }
    285 
    286    if (set_alpha)
    287       ret |= mask ? FS_MASK_SET_ALPHA : FS_SRC_SET_ALPHA;
    288    if (swizzle)
    289       ret |= mask ? FS_MASK_SWIZZLE_RGB : FS_SRC_SWIZZLE_RGB;
    290 
    291    return ret;
    292 }
    293 
    294 static void
    295 bind_shaders(struct exa_context *exa, int op,
    296              PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture,
    297              struct exa_pixmap_priv *pSrc, struct exa_pixmap_priv *pMask)
    298 {
    299    unsigned vs_traits = 0, fs_traits = 0;
    300    struct xorg_shader shader;
    301 
    302    exa->has_solid_color = FALSE;
    303 
    304    if (pSrcPicture) {
    305       if (pSrcPicture->repeatType == RepeatNone && pSrcPicture->transform)
    306          fs_traits |= FS_SRC_REPEAT_NONE;
    307 
    308       if (pSrcPicture->pSourcePict) {
    309          if (pSrcPicture->pSourcePict->type == SourcePictTypeSolidFill) {
    310             fs_traits |= FS_SOLID_FILL;
    311             vs_traits |= VS_SOLID_FILL;
    312             debug_assert(pSrcPicture->format == PICT_a8r8g8b8);
    313             pixel_to_float4(pSrcPicture->pSourcePict->solidFill.color,
    314                             exa->solid_color, PIPE_FORMAT_B8G8R8A8_UNORM);
    315             exa->has_solid_color = TRUE;
    316          } else {
    317             debug_assert("!gradients not supported");
    318          }
    319       } else {
    320          fs_traits |= FS_COMPOSITE;
    321          vs_traits |= VS_COMPOSITE;
    322       }
    323 
    324       fs_traits |= picture_format_fixups(pSrc, pSrcPicture, FALSE, pDstPicture);
    325    }
    326 
    327    if (pMaskPicture) {
    328       vs_traits |= VS_MASK;
    329       fs_traits |= FS_MASK;
    330       if (pMaskPicture->repeatType == RepeatNone && pMaskPicture->transform)
    331          fs_traits |= FS_MASK_REPEAT_NONE;
    332       if (pMaskPicture->componentAlpha) {
    333          struct xorg_composite_blend blend;
    334          blend_for_op(&blend, op,
    335                       pSrcPicture, pMaskPicture, NULL);
    336          if (blend.alpha_src) {
    337             fs_traits |= FS_CA_SRCALPHA;
    338          } else
    339             fs_traits |= FS_CA_FULL;
    340       }
    341 
    342       fs_traits |= picture_format_fixups(pMask, pMaskPicture, TRUE, pDstPicture);
    343    }
    344 
    345    shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits);
    346    cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs);
    347    cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs);
    348 }
    349 
    350 static void
    351 bind_samplers(struct exa_context *exa, int op,
    352               PicturePtr pSrcPicture, PicturePtr pMaskPicture,
    353               PicturePtr pDstPicture,
    354               struct exa_pixmap_priv *pSrc,
    355               struct exa_pixmap_priv *pMask,
    356               struct exa_pixmap_priv *pDst)
    357 {
    358    struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS] = {0};
    359    struct pipe_sampler_state src_sampler, mask_sampler;
    360    struct pipe_sampler_view view_templ;
    361    struct pipe_sampler_view *src_view;
    362    struct pipe_context *pipe = exa->pipe;
    363 
    364    exa->num_bound_samplers = 0;
    365 
    366    memset(&src_sampler, 0, sizeof(struct pipe_sampler_state));
    367    memset(&mask_sampler, 0, sizeof(struct pipe_sampler_state));
    368 
    369    if (pSrcPicture && pSrc) {
    370       if (exa->has_solid_color) {
    371          debug_assert(!"solid color with textures");
    372          samplers[0] = NULL;
    373          pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL);
    374       } else {
    375          unsigned src_wrap = render_repeat_to_gallium(
    376             pSrcPicture->repeatType);
    377          int filter;
    378 
    379          render_filter_to_gallium(pSrcPicture->filter, &filter);
    380 
    381          src_sampler.wrap_s = src_wrap;
    382          src_sampler.wrap_t = src_wrap;
    383          src_sampler.min_img_filter = filter;
    384          src_sampler.mag_img_filter = filter;
    385          src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
    386          src_sampler.normalized_coords = 1;
    387          samplers[0] = &src_sampler;
    388          exa->num_bound_samplers = 1;
    389          u_sampler_view_default_template(&view_templ,
    390                                          pSrc->tex,
    391                                          pSrc->tex->format);
    392          src_view = pipe->create_sampler_view(pipe, pSrc->tex, &view_templ);
    393          pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL);
    394          exa->bound_sampler_views[0] = src_view;
    395       }
    396    }
    397 
    398    if (pMaskPicture && pMask) {
    399       unsigned mask_wrap = render_repeat_to_gallium(
    400          pMaskPicture->repeatType);
    401       int filter;
    402 
    403       render_filter_to_gallium(pMaskPicture->filter, &filter);
    404 
    405       mask_sampler.wrap_s = mask_wrap;
    406       mask_sampler.wrap_t = mask_wrap;
    407       mask_sampler.min_img_filter = filter;
    408       mask_sampler.mag_img_filter = filter;
    409       src_sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
    410       mask_sampler.normalized_coords = 1;
    411       samplers[1] = &mask_sampler;
    412       exa->num_bound_samplers = 2;
    413       u_sampler_view_default_template(&view_templ,
    414                                       pMask->tex,
    415                                       pMask->tex->format);
    416       src_view = pipe->create_sampler_view(pipe, pMask->tex, &view_templ);
    417       pipe_sampler_view_reference(&exa->bound_sampler_views[1], NULL);
    418       exa->bound_sampler_views[1] = src_view;
    419    }
    420 
    421    cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT,
    422                     exa->num_bound_samplers,
    423                     (const struct pipe_sampler_state **)samplers);
    424    cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT,
    425                          exa->num_bound_samplers,
    426                          exa->bound_sampler_views);
    427 }
    428 
    429 
    430 
    431 static INLINE boolean matrix_from_pict_transform(PictTransform *trans, float *matrix)
    432 {
    433    if (!trans)
    434       return FALSE;
    435 
    436    matrix[0] = XFixedToDouble(trans->matrix[0][0]);
    437    matrix[3] = XFixedToDouble(trans->matrix[0][1]);
    438    matrix[6] = XFixedToDouble(trans->matrix[0][2]);
    439 
    440    matrix[1] = XFixedToDouble(trans->matrix[1][0]);
    441    matrix[4] = XFixedToDouble(trans->matrix[1][1]);
    442    matrix[7] = XFixedToDouble(trans->matrix[1][2]);
    443 
    444    matrix[2] = XFixedToDouble(trans->matrix[2][0]);
    445    matrix[5] = XFixedToDouble(trans->matrix[2][1]);
    446    matrix[8] = XFixedToDouble(trans->matrix[2][2]);
    447 
    448    return TRUE;
    449 }
    450 
    451 static void
    452 setup_transforms(struct  exa_context *exa,
    453                  PicturePtr pSrcPicture, PicturePtr pMaskPicture)
    454 {
    455    PictTransform *src_t = NULL;
    456    PictTransform *mask_t = NULL;
    457 
    458    if (pSrcPicture)
    459       src_t = pSrcPicture->transform;
    460    if (pMaskPicture)
    461       mask_t = pMaskPicture->transform;
    462 
    463    exa->transform.has_src  =
    464       matrix_from_pict_transform(src_t, exa->transform.src);
    465    exa->transform.has_mask =
    466       matrix_from_pict_transform(mask_t, exa->transform.mask);
    467 }
    468 
    469 boolean xorg_composite_bind_state(struct exa_context *exa,
    470                                   int op,
    471                                   PicturePtr pSrcPicture,
    472                                   PicturePtr pMaskPicture,
    473                                   PicturePtr pDstPicture,
    474                                   struct exa_pixmap_priv *pSrc,
    475                                   struct exa_pixmap_priv *pMask,
    476                                   struct exa_pixmap_priv *pDst)
    477 {
    478    struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pDst);
    479 
    480    renderer_bind_destination(exa->renderer, dst_surf,
    481                              pDst->width,
    482                              pDst->height);
    483 
    484    bind_blend_state(exa, op, pSrcPicture, pMaskPicture, pDstPicture);
    485    bind_shaders(exa, op, pSrcPicture, pMaskPicture, pDstPicture, pSrc, pMask);
    486    bind_samplers(exa, op, pSrcPicture, pMaskPicture,
    487                  pDstPicture, pSrc, pMask, pDst);
    488 
    489    setup_transforms(exa, pSrcPicture, pMaskPicture);
    490 
    491    if (exa->num_bound_samplers == 0 ) { /* solid fill */
    492       renderer_begin_solid(exa->renderer);
    493    } else {
    494       renderer_begin_textures(exa->renderer,
    495                               exa->num_bound_samplers);
    496    }
    497 
    498 
    499    pipe_surface_reference(&dst_surf, NULL);
    500    return TRUE;
    501 }
    502 
    503 void xorg_composite(struct exa_context *exa,
    504                     struct exa_pixmap_priv *dst,
    505                     int srcX, int srcY, int maskX, int maskY,
    506                     int dstX, int dstY, int width, int height)
    507 {
    508    if (exa->num_bound_samplers == 0 ) { /* solid fill */
    509       renderer_solid(exa->renderer,
    510                      dstX, dstY, dstX + width, dstY + height,
    511                      exa->solid_color);
    512    } else {
    513       int pos[6] = {srcX, srcY, maskX, maskY, dstX, dstY};
    514       float *src_matrix = NULL;
    515       float *mask_matrix = NULL;
    516 
    517       if (exa->transform.has_src)
    518          src_matrix = exa->transform.src;
    519       if (exa->transform.has_mask)
    520          mask_matrix = exa->transform.mask;
    521 
    522       renderer_texture(exa->renderer,
    523                        pos, width, height,
    524                        exa->bound_sampler_views,
    525                        exa->num_bound_samplers,
    526                        src_matrix, mask_matrix);
    527    }
    528 }
    529 
    530 boolean xorg_solid_bind_state(struct exa_context *exa,
    531                               struct exa_pixmap_priv *pixmap,
    532                               Pixel fg)
    533 {
    534    struct pipe_surface *dst_surf = xorg_gpu_surface(exa->pipe, pixmap);
    535    unsigned vs_traits, fs_traits;
    536    struct xorg_shader shader;
    537 
    538    pixel_to_float4(fg, exa->solid_color, pixmap->tex->format);
    539    exa->has_solid_color = TRUE;
    540 
    541 #if 0
    542    debug_printf("Color Pixel=(%d, %d, %d, %d), RGBA=(%f, %f, %f, %f)\n",
    543                 (fg >> 24) & 0xff, (fg >> 16) & 0xff,
    544                 (fg >> 8) & 0xff,  (fg >> 0) & 0xff,
    545                 exa->solid_color[0], exa->solid_color[1],
    546                 exa->solid_color[2], exa->solid_color[3]);
    547 #endif
    548 
    549    vs_traits = VS_SOLID_FILL;
    550    fs_traits = FS_SOLID_FILL;
    551 
    552    renderer_bind_destination(exa->renderer, dst_surf,
    553                              pixmap->width, pixmap->height);
    554    bind_blend_state(exa, PictOpSrc, NULL, NULL, NULL);
    555    cso_set_samplers(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL);
    556    cso_set_sampler_views(exa->renderer->cso, PIPE_SHADER_FRAGMENT, 0, NULL);
    557 
    558    shader = xorg_shaders_get(exa->renderer->shaders, vs_traits, fs_traits);
    559    cso_set_vertex_shader_handle(exa->renderer->cso, shader.vs);
    560    cso_set_fragment_shader_handle(exa->renderer->cso, shader.fs);
    561 
    562    renderer_begin_solid(exa->renderer);
    563 
    564    pipe_surface_reference(&dst_surf, NULL);
    565    return TRUE;
    566 }
    567 
    568 void xorg_solid(struct exa_context *exa,
    569                 struct exa_pixmap_priv *pixmap,
    570                 int x0, int y0, int x1, int y1)
    571 {
    572    renderer_solid(exa->renderer,
    573                   x0, y0, x1, y1, exa->solid_color);
    574 }
    575 
    576 void
    577 xorg_composite_done(struct exa_context *exa)
    578 {
    579    renderer_draw_flush(exa->renderer);
    580 
    581    exa->transform.has_src = FALSE;
    582    exa->transform.has_mask = FALSE;
    583    exa->has_solid_color = FALSE;
    584    exa->num_bound_samplers = 0;
    585 }
    586