/* * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. * All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the * "Software"), to deal in the Software without restriction, including * without limitation the rights to use, copy, modify, merge, publish, * distribute, sub license, and/or sell copies of the Software, and to * permit persons to whom the Software is furnished to do so, subject to * the following conditions: * * The above copyright notice and this permission notice (including the * next paragraph) shall be included in all copies or substantial portions * of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * * Author: Alan Hourihane * Author: Jakob Bornecrantz * */ #include "xorg_exa.h" #include "xorg_tracker.h" #include "xorg_composite.h" #include "xorg_exa_tgsi.h" #include #include #include #include #include "pipe/p_format.h" #include "pipe/p_context.h" #include "pipe/p_state.h" #include "util/u_rect.h" #include "util/u_math.h" #include "util/u_debug.h" #include "util/u_format.h" #include "util/u_box.h" #include "util/u_surface.h" #define ROUND_UP_TEXTURES 1 static INLINE void exa_debug_printf(const char *format, ...) _util_printf_format(1,2); static INLINE void exa_debug_printf(const char *format, ...) { #if 0 va_list ap; va_start(ap, format); _debug_vprintf(format, ap); va_end(ap); #else (void) format; /* silence warning */ #endif } /* * Helper functions */ struct render_format_str { int format; const char *name; }; static const struct render_format_str formats_info[] = { {PICT_a8r8g8b8, "PICT_a8r8g8b8"}, {PICT_x8r8g8b8, "PICT_x8r8g8b8"}, {PICT_a8b8g8r8, "PICT_a8b8g8r8"}, {PICT_x8b8g8r8, "PICT_x8b8g8r8"}, #ifdef PICT_TYPE_BGRA {PICT_b8g8r8a8, "PICT_b8g8r8a8"}, {PICT_b8g8r8x8, "PICT_b8g8r8x8"}, {PICT_a2r10g10b10, "PICT_a2r10g10b10"}, {PICT_x2r10g10b10, "PICT_x2r10g10b10"}, {PICT_a2b10g10r10, "PICT_a2b10g10r10"}, {PICT_x2b10g10r10, "PICT_x2b10g10r10"}, #endif {PICT_r8g8b8, "PICT_r8g8b8"}, {PICT_b8g8r8, "PICT_b8g8r8"}, {PICT_r5g6b5, "PICT_r5g6b5"}, {PICT_b5g6r5, "PICT_b5g6r5"}, {PICT_a1r5g5b5, "PICT_a1r5g5b5"}, {PICT_x1r5g5b5, "PICT_x1r5g5b5"}, {PICT_a1b5g5r5, "PICT_a1b5g5r5"}, {PICT_x1b5g5r5, "PICT_x1b5g5r5"}, {PICT_a4r4g4b4, "PICT_a4r4g4b4"}, {PICT_x4r4g4b4, "PICT_x4r4g4b4"}, {PICT_a4b4g4r4, "PICT_a4b4g4r4"}, {PICT_x4b4g4r4, "PICT_x4b4g4r4"}, {PICT_a8, "PICT_a8"}, {PICT_r3g3b2, "PICT_r3g3b2"}, {PICT_b2g3r3, "PICT_b2g3r3"}, {PICT_a2r2g2b2, "PICT_a2r2g2b2"}, {PICT_a2b2g2r2, "PICT_a2b2g2r2"}, {PICT_c8, "PICT_c8"}, {PICT_g8, "PICT_g8"}, {PICT_x4a4, "PICT_x4a4"}, {PICT_x4c4, "PICT_x4c4"}, {PICT_x4g4, "PICT_x4g4"}, {PICT_a4, "PICT_a4"}, {PICT_r1g2b1, "PICT_r1g2b1"}, {PICT_b1g2r1, "PICT_b1g2r1"}, {PICT_a1r1g1b1, "PICT_a1r1g1b1"}, {PICT_a1b1g1r1, "PICT_a1b1g1r1"}, {PICT_c4, "PICT_c4"}, {PICT_g4, "PICT_g4"}, {PICT_a1, "PICT_a1"}, {PICT_g1, "PICT_g1"} }; static const char *render_format_name(int format) { int i = 0; for (i = 0; i < sizeof(formats_info)/sizeof(formats_info[0]); ++i) { if (formats_info[i].format == format) return formats_info[i].name; } return NULL; } static void exa_get_pipe_format(int depth, enum pipe_format *format, int *bbp, int *picture_format) { switch (depth) { case 32: *format = PIPE_FORMAT_B8G8R8A8_UNORM; *picture_format = PICT_a8r8g8b8; assert(*bbp == 32); break; case 24: *format = PIPE_FORMAT_B8G8R8X8_UNORM; *picture_format = PICT_x8r8g8b8; assert(*bbp == 32); break; case 16: *format = PIPE_FORMAT_B5G6R5_UNORM; *picture_format = PICT_r5g6b5; assert(*bbp == 16); break; case 15: *format = PIPE_FORMAT_B5G5R5A1_UNORM; *picture_format = PICT_x1r5g5b5; assert(*bbp == 16); break; case 8: *format = PIPE_FORMAT_L8_UNORM; *picture_format = PICT_a8; assert(*bbp == 8); break; case 4: case 1: *format = PIPE_FORMAT_B8G8R8A8_UNORM; /* bad bad bad */ break; default: assert(0); break; } } /* * Static exported EXA functions */ static void ExaWaitMarker(ScreenPtr pScreen, int marker) { /* Nothing to do, handled in the PrepareAccess hook */ } static int ExaMarkSync(ScreenPtr pScreen) { return 1; } /*********************************************************************** * Screen upload/download */ static Bool ExaDownloadFromScreen(PixmapPtr pPix, int x, int y, int w, int h, char *dst, int dst_pitch) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix); struct pipe_transfer *transfer; void *map; if (!priv || !priv->tex) return FALSE; map = pipe_transfer_map(exa->pipe, priv->tex, 0, 0, PIPE_TRANSFER_READ, x, y, w, h, &transfer); if (!map) return FALSE; exa_debug_printf("------ ExaDownloadFromScreen(%d, %d, %d, %d, %d)\n", x, y, w, h, dst_pitch); util_copy_rect((unsigned char*)dst, priv->tex->format, dst_pitch, 0, 0, w, h, map, transfer->stride, 0, 0); exa->pipe->transfer_unmap(exa->pipe, transfer); return TRUE; } static Bool ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src, int src_pitch) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix); struct pipe_transfer *transfer; void *map; if (!priv || !priv->tex) return FALSE; map = pipe_transfer_map(exa->pipe, priv->tex, 0, 0, PIPE_TRANSFER_WRITE, x, y, w, h, &transfer); if (!map) return FALSE; exa_debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n", x, y, w, h, src_pitch); util_copy_rect(map, priv->tex->format, transfer->stride, 0, 0, w, h, (unsigned char*)src, src_pitch, 0, 0); exa->pipe->transfer_unmap(exa->pipe, transfer); return TRUE; } static Bool ExaPrepareAccess(PixmapPtr pPix, int index) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPix); if (!priv) return FALSE; if (!priv->tex) return FALSE; exa_debug_printf("ExaPrepareAccess %d\n", index); if (priv->map_count == 0) { assert(pPix->drawable.width <= priv->tex->width0); assert(pPix->drawable.height <= priv->tex->height0); pPix->devPrivate.ptr = pipe_transfer_map(exa->pipe, priv->tex, 0, 0, #ifdef EXA_MIXED_PIXMAPS PIPE_TRANSFER_MAP_DIRECTLY | #endif PIPE_TRANSFER_READ_WRITE, 0, 0, pPix->drawable.width, pPix->drawable.height, &priv->map_transfer); if (!pPix->devPrivate.ptr) #ifdef EXA_MIXED_PIXMAPS return FALSE; #else FatalError("failed to create transfer\n"); #endif pPix->devKind = priv->map_transfer->stride; } priv->map_count++; exa_debug_printf("ExaPrepareAccess %d prepared\n", index); return TRUE; } static void ExaFinishAccess(PixmapPtr pPix, int index) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPix); if (!priv) return; if (!priv->map_transfer || pPix->devPrivate.ptr == NULL) return; exa_debug_printf("ExaFinishAccess %d\n", index); if (--priv->map_count == 0) { assert(priv->map_transfer); exa->pipe->transfer_unmap(exa->pipe, priv->map_transfer); priv->map_transfer = NULL; pPix->devPrivate.ptr = NULL; } exa_debug_printf("ExaFinishAccess %d finished\n", index); } /*********************************************************************** * Solid Fills */ static Bool ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct exa_context *exa = ms->exa; exa_debug_printf("ExaPrepareSolid(0x%x)\n", fg); if (!exa->accel) return FALSE; if (!exa->pipe) XORG_FALLBACK("accel not enabled"); if (!priv || !priv->tex) XORG_FALLBACK("%s", !priv ? "!priv" : "!priv->tex"); if (!EXA_PM_IS_SOLID(&pPixmap->drawable, planeMask)) XORG_FALLBACK("planeMask is not solid"); if (alu != GXcopy) XORG_FALLBACK("not GXcopy"); if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, PIPE_BIND_RENDER_TARGET)) { XORG_FALLBACK("format %s", util_format_name(priv->tex->format)); } return xorg_solid_bind_state(exa, priv, fg); } static void ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); exa_debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1); if (x0 == 0 && y0 == 0 && x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) { union pipe_color_union solid_color; solid_color.f[0] = exa->solid_color[0]; solid_color.f[1] = exa->solid_color[1]; solid_color.f[2] = exa->solid_color[2]; solid_color.f[3] = exa->solid_color[3]; exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, &solid_color, 0.0, 0); return; } xorg_solid(exa, priv, x0, y0, x1, y1) ; } static void ExaDoneSolid(PixmapPtr pPixmap) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct exa_context *exa = ms->exa; if (!priv) return; exa_debug_printf("ExaDoneSolid\n"); xorg_composite_done(exa); exa_debug_printf("ExaDoneSolid done\n"); } /*********************************************************************** * Copy Blits */ static Bool ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir, int ydir, int alu, Pixel planeMask) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pDstPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap); struct exa_pixmap_priv *src_priv = exaGetPixmapDriverPrivate(pSrcPixmap); exa_debug_printf("ExaPrepareCopy\n"); if (!exa->accel) return FALSE; if (!exa->pipe) XORG_FALLBACK("accel not enabled"); if (!priv || !priv->tex) XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex"); if (!src_priv || !src_priv->tex) XORG_FALLBACK("pSrc %s", !src_priv ? "!priv" : "!priv->tex"); if (!EXA_PM_IS_SOLID(&pSrcPixmap->drawable, planeMask)) XORG_FALLBACK("planeMask is not solid"); if (alu != GXcopy) XORG_FALLBACK("alu not GXcopy"); if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, PIPE_BIND_RENDER_TARGET)) XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format)); if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format, src_priv->tex->target, 0, PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format)); exa->copy.src = src_priv; exa->copy.dst = priv; return TRUE; } static void ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY, int width, int height) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pDstPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct pipe_box src_box; exa_debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n", srcX, srcY, dstX, dstY, width, height); debug_assert(exaGetPixmapDriverPrivate(pDstPixmap) == exa->copy.dst); u_box_2d(srcX, srcY, width, height, &src_box); /* If source and destination overlap, we have to copy to/from a scratch * pixmap. */ if (exa->copy.dst == exa->copy.src && !((dstX + width) < srcX || dstX > (srcX + width) || (dstY + height) < srcY || dstY > (srcY + height))) { struct exa_pixmap_priv *tmp_priv; if (!exa->copy.tmp_pix) { exa->copy.tmp_pix = pScrn->pScreen->CreatePixmap(pScrn->pScreen, pDstPixmap->drawable.width, pDstPixmap->drawable.height, pDstPixmap->drawable.depth, pDstPixmap->drawable.width); exaMoveInPixmap(exa->copy.tmp_pix); } tmp_priv = exaGetPixmapDriverPrivate(exa->copy.tmp_pix); exa->pipe->resource_copy_region( exa->pipe, tmp_priv->tex, 0, srcX, srcY, 0, exa->copy.src->tex, 0, &src_box); exa->pipe->resource_copy_region( exa->pipe, exa->copy.dst->tex, 0, dstX, dstY, 0, tmp_priv->tex, 0, &src_box); } else exa->pipe->resource_copy_region( exa->pipe, exa->copy.dst->tex, 0, dstX, dstY, 0, exa->copy.src->tex, 0, &src_box); } static void ExaDoneCopy(PixmapPtr pPixmap) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct exa_context *exa = ms->exa; if (!priv) return; exa_debug_printf("ExaDoneCopy\n"); if (exa->copy.tmp_pix) { pScrn->pScreen->DestroyPixmap(exa->copy.tmp_pix); exa->copy.tmp_pix = NULL; } exa->copy.src = NULL; exa->copy.dst = NULL; exa_debug_printf("ExaDoneCopy done\n"); } static Bool picture_check_formats(struct exa_pixmap_priv *pSrc, PicturePtr pSrcPicture) { if (pSrc->picture_format == pSrcPicture->format) return TRUE; if (pSrc->picture_format != PICT_a8r8g8b8) return FALSE; /* pSrc->picture_format == PICT_a8r8g8b8 */ switch (pSrcPicture->format) { case PICT_a8r8g8b8: case PICT_x8r8g8b8: case PICT_a8b8g8r8: case PICT_x8b8g8r8: /* just treat these two as x8... */ case PICT_r8g8b8: case PICT_b8g8r8: return TRUE; #ifdef PICT_TYPE_BGRA case PICT_b8g8r8a8: case PICT_b8g8r8x8: return FALSE; /* does not support swizzleing the alpha channel yet */ case PICT_a2r10g10b10: case PICT_x2r10g10b10: case PICT_a2b10g10r10: case PICT_x2b10g10r10: return FALSE; #endif default: return FALSE; } return FALSE; } /*********************************************************************** * Composite entrypoints */ static Bool ExaCheckComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pDstPicture->pDrawable->pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; Bool accelerated = exa->accel && xorg_composite_accelerated(op, pSrcPicture, pMaskPicture, pDstPicture); exa_debug_printf("ExaCheckComposite(%d, %p, %p, %p) = %d\n", op, pSrcPicture, pMaskPicture, pDstPicture, accelerated); return accelerated; } static Bool ExaPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture, PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pDst->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv; if (!exa->accel) return FALSE; exa_debug_printf("ExaPrepareComposite(%d, src=0x%p, mask=0x%p, dst=0x%p)\n", op, pSrcPicture, pMaskPicture, pDstPicture); exa_debug_printf("\tFormats: src(%s), mask(%s), dst(%s)\n", pSrcPicture ? render_format_name(pSrcPicture->format) : "none", pMaskPicture ? render_format_name(pMaskPicture->format) : "none", pDstPicture ? render_format_name(pDstPicture->format) : "none"); if (!exa->pipe) XORG_FALLBACK("accel not enabled"); priv = exaGetPixmapDriverPrivate(pDst); if (!priv || !priv->tex) XORG_FALLBACK("pDst %s", !priv ? "!priv" : "!priv->tex"); if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, PIPE_BIND_RENDER_TARGET)) XORG_FALLBACK("pDst format: %s", util_format_name(priv->tex->format)); if (priv->picture_format != pDstPicture->format) XORG_FALLBACK("pDst pic_format: %s != %s", render_format_name(priv->picture_format), render_format_name(pDstPicture->format)); if (pSrc) { priv = exaGetPixmapDriverPrivate(pSrc); if (!priv || !priv->tex) XORG_FALLBACK("pSrc %s", !priv ? "!priv" : "!priv->tex"); if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pSrc format: %s", util_format_name(priv->tex->format)); if (!picture_check_formats(priv, pSrcPicture)) XORG_FALLBACK("pSrc pic_format: %s != %s", render_format_name(priv->picture_format), render_format_name(pSrcPicture->format)); } if (pMask) { priv = exaGetPixmapDriverPrivate(pMask); if (!priv || !priv->tex) XORG_FALLBACK("pMask %s", !priv ? "!priv" : "!priv->tex"); if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format, priv->tex->target, 0, PIPE_BIND_SAMPLER_VIEW)) XORG_FALLBACK("pMask format: %s", util_format_name(priv->tex->format)); if (!picture_check_formats(priv, pMaskPicture)) XORG_FALLBACK("pMask pic_format: %s != %s", render_format_name(priv->picture_format), render_format_name(pMaskPicture->format)); } return xorg_composite_bind_state(exa, op, pSrcPicture, pMaskPicture, pDstPicture, pSrc ? exaGetPixmapDriverPrivate(pSrc) : NULL, pMask ? exaGetPixmapDriverPrivate(pMask) : NULL, exaGetPixmapDriverPrivate(pDst)); } static void ExaComposite(PixmapPtr pDst, int srcX, int srcY, int maskX, int maskY, int dstX, int dstY, int width, int height) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pDst->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDst); exa_debug_printf("\tExaComposite(src[%d,%d], mask=[%d, %d], dst=[%d, %d], dim=[%d, %d])\n", srcX, srcY, maskX, maskY, dstX, dstY, width, height); exa_debug_printf("\t Num bound samplers = %d\n", exa->num_bound_samplers); xorg_composite(exa, priv, srcX, srcY, maskX, maskY, dstX, dstY, width, height); } static void ExaDoneComposite(PixmapPtr pPixmap) { ScrnInfoPtr pScrn = xf86ScreenToScrn(pPixmap->drawable.pScreen); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; xorg_composite_done(exa); } /*********************************************************************** * Pixmaps */ static void * ExaCreatePixmap(ScreenPtr pScreen, int size, int align) { struct exa_pixmap_priv *priv; priv = calloc(1, sizeof(struct exa_pixmap_priv)); if (!priv) return NULL; return priv; } static void ExaDestroyPixmap(ScreenPtr pScreen, void *dPriv) { struct exa_pixmap_priv *priv = (struct exa_pixmap_priv *)dPriv; if (!priv) return; pipe_resource_reference(&priv->tex, NULL); free(priv); } static Bool ExaPixmapIsOffscreen(PixmapPtr pPixmap) { struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPixmap); if (!priv) return FALSE; if (priv->tex) return TRUE; return FALSE; } int xorg_exa_set_displayed_usage(PixmapPtr pPixmap) { struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPixmap); if (!priv) { FatalError("NO PIXMAP PRIVATE\n"); return 0; } priv->flags |= PIPE_BIND_SCANOUT; return 0; } int xorg_exa_set_shared_usage(PixmapPtr pPixmap) { struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPixmap); if (!priv) { FatalError("NO PIXMAP PRIVATE\n"); return 0; } priv->flags |= PIPE_BIND_SHARED; return 0; } static Bool size_match( int width, int tex_width ) { #if ROUND_UP_TEXTURES if (width > tex_width) return FALSE; if (width * 2 < tex_width) return FALSE; return TRUE; #else return width == tex_width; #endif } static Bool ExaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, int depth, int bitsPerPixel, int devKind, pointer pPixData) { ScreenPtr pScreen = pPixmap->drawable.pScreen; ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; if (!priv || pPixData) return FALSE; if (0) { debug_printf("%s pixmap %p sz %dx%dx%d devKind %d\n", __FUNCTION__, pPixmap, width, height, bitsPerPixel, devKind); if (priv->tex) debug_printf(" ==> old texture %dx%d\n", priv->tex->width0, priv->tex->height0); } if (depth <= 0) depth = pPixmap->drawable.depth; if (bitsPerPixel <= 0) bitsPerPixel = pPixmap->drawable.bitsPerPixel; if (width <= 0) width = pPixmap->drawable.width; if (height <= 0) height = pPixmap->drawable.height; if (width <= 0 || height <= 0 || depth <= 0) return FALSE; miModifyPixmapHeader(pPixmap, width, height, depth, bitsPerPixel, devKind, NULL); priv->width = width; priv->height = height; /* Deal with screen resize */ if ((exa->accel || priv->flags) && (!priv->tex || !size_match(width, priv->tex->width0) || !size_match(height, priv->tex->height0) || priv->tex_flags != priv->flags)) { struct pipe_resource *texture = NULL; struct pipe_resource template; memset(&template, 0, sizeof(template)); template.target = PIPE_TEXTURE_2D; exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &priv->picture_format); if (ROUND_UP_TEXTURES && priv->flags == 0) { template.width0 = util_next_power_of_two(width); template.height0 = util_next_power_of_two(height); } else { template.width0 = width; template.height0 = height; } template.depth0 = 1; template.array_size = 1; template.last_level = 0; template.bind = PIPE_BIND_RENDER_TARGET | priv->flags; priv->tex_flags = priv->flags; texture = exa->scrn->resource_create(exa->scrn, &template); if (priv->tex) { struct pipe_box src_box; u_box_origin_2d(min(width, texture->width0), min(height, texture->height0), &src_box); exa->pipe->resource_copy_region(exa->pipe, texture, 0, 0, 0, 0, priv->tex, 0, &src_box); } pipe_resource_reference(&priv->tex, texture); /* the texture we create has one reference */ pipe_resource_reference(&texture, NULL); } return TRUE; } struct pipe_resource * xorg_exa_get_texture(PixmapPtr pPixmap) { struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct pipe_resource *tex = NULL; pipe_resource_reference(&tex, priv->tex); return tex; } Bool xorg_exa_set_texture(PixmapPtr pPixmap, struct pipe_resource *tex) { struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); int mask = PIPE_BIND_SHARED | PIPE_BIND_SCANOUT; if (!priv) return FALSE; if (pPixmap->drawable.width != tex->width0 || pPixmap->drawable.height != tex->height0) return FALSE; pipe_resource_reference(&priv->tex, tex); priv->tex_flags = tex->bind & mask; return TRUE; } struct pipe_resource * xorg_exa_create_root_texture(ScrnInfoPtr pScrn, int width, int height, int depth, int bitsPerPixel) { modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct pipe_resource template; int dummy; memset(&template, 0, sizeof(template)); template.target = PIPE_TEXTURE_2D; exa_get_pipe_format(depth, &template.format, &bitsPerPixel, &dummy); template.width0 = width; template.height0 = height; template.depth0 = 1; template.array_size = 1; template.last_level = 0; template.bind |= PIPE_BIND_RENDER_TARGET; template.bind |= PIPE_BIND_SCANOUT; template.bind |= PIPE_BIND_SHARED; return exa->scrn->resource_create(exa->scrn, &template); } void xorg_exa_close(ScrnInfoPtr pScrn) { modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; pipe_sampler_view_reference(&exa->bound_sampler_views[0], NULL); pipe_sampler_view_reference(&exa->bound_sampler_views[1], NULL); renderer_destroy(exa->renderer); xorg_exa_finish(exa); if (exa->pipe) exa->pipe->destroy(exa->pipe); exa->pipe = NULL; /* Since this was shared be proper with the pointer */ ms->ctx = NULL; exaDriverFini(pScrn->pScreen); free(exa); ms->exa = NULL; } void * xorg_exa_init(ScrnInfoPtr pScrn, Bool accel) { modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa; ExaDriverPtr pExa; CustomizerPtr cust = ms->cust; exa = calloc(1, sizeof(struct exa_context)); if (!exa) return NULL; exa->scrn = ms->screen; exa->pipe = exa->scrn->context_create(exa->scrn, NULL); if (exa->pipe == NULL) goto out_err; pExa = exaDriverAlloc(); if (!pExa) { goto out_err; } pExa->exa_major = 2; pExa->exa_minor = 2; pExa->memoryBase = 0; pExa->memorySize = 0; pExa->offScreenBase = 0; pExa->pixmapOffsetAlign = 0; pExa->pixmapPitchAlign = 1; pExa->flags = EXA_OFFSCREEN_PIXMAPS | EXA_HANDLES_PIXMAPS; #ifdef EXA_SUPPORTS_PREPARE_AUX pExa->flags |= EXA_SUPPORTS_PREPARE_AUX; #endif #ifdef EXA_MIXED_PIXMAPS pExa->flags |= EXA_MIXED_PIXMAPS; #endif pExa->maxX = pExa->maxY = 1 << (exa->scrn->get_param(exa->scrn, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1); pExa->WaitMarker = ExaWaitMarker; pExa->MarkSync = ExaMarkSync; pExa->PrepareSolid = ExaPrepareSolid; pExa->Solid = ExaSolid; pExa->DoneSolid = ExaDoneSolid; pExa->PrepareCopy = ExaPrepareCopy; pExa->Copy = ExaCopy; pExa->DoneCopy = ExaDoneCopy; pExa->CheckComposite = ExaCheckComposite; pExa->PrepareComposite = ExaPrepareComposite; pExa->Composite = ExaComposite; pExa->DoneComposite = ExaDoneComposite; pExa->PixmapIsOffscreen = ExaPixmapIsOffscreen; pExa->DownloadFromScreen = ExaDownloadFromScreen; pExa->UploadToScreen = ExaUploadToScreen; pExa->PrepareAccess = ExaPrepareAccess; pExa->FinishAccess = ExaFinishAccess; pExa->CreatePixmap = ExaCreatePixmap; pExa->DestroyPixmap = ExaDestroyPixmap; pExa->ModifyPixmapHeader = ExaModifyPixmapHeader; if (!exaDriverInit(pScrn->pScreen, pExa)) { goto out_err; } /* Share context with DRI */ ms->ctx = exa->pipe; if (cust && cust->winsys_context_throttle) cust->winsys_context_throttle(cust, ms->ctx, THROTTLE_RENDER); exa->renderer = renderer_create(exa->pipe); exa->accel = accel; return (void *)exa; out_err: xorg_exa_close(pScrn); free(exa); return NULL; } struct pipe_surface * xorg_gpu_surface(struct pipe_context *pipe, struct exa_pixmap_priv *priv) { struct pipe_surface surf_tmpl; memset(&surf_tmpl, 0, sizeof(surf_tmpl)); u_surface_default_template(&surf_tmpl, priv->tex, PIPE_BIND_RENDER_TARGET); return pipe->create_surface(pipe, priv->tex, &surf_tmpl); } void xorg_exa_flush(struct exa_context *exa, struct pipe_fence_handle **fence) { exa->pipe->flush(exa->pipe, fence); } void xorg_exa_finish(struct exa_context *exa) { struct pipe_fence_handle *fence = NULL; xorg_exa_flush(exa, &fence); exa->pipe->screen->fence_finish(exa->pipe->screen, fence, PIPE_TIMEOUT_INFINITE); exa->pipe->screen->fence_reference(exa->pipe->screen, &fence, NULL); }