static Bool RADEONPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg) { RINFO_FROM_SCREEN(pPix->drawable.pScreen); uint32_t datatype, dst_pitch_offset; struct radeon_exa_pixmap_priv *driver_priv; int ret; TRACE; if (pPix->drawable.bitsPerPixel == 24) RADEON_FALLBACK(("24bpp unsupported\n")); if (!RADEONGetDatatypeBpp(pPix->drawable.bitsPerPixel, &datatype)) RADEON_FALLBACK(("RADEONGetDatatypeBpp failed\n")); if (!RADEONGetPixmapOffsetPitch(pPix, &dst_pitch_offset)) RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch failed\n")); RADEON_SWITCH_TO_2D(); radeon_cs_space_reset_bos(info->cs); driver_priv = exaGetPixmapDriverPrivate(pPix); radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, 0, RADEON_GEM_DOMAIN_VRAM); ret = radeon_cs_space_check(info->cs); if (ret) RADEON_FALLBACK(("Not enough RAM to hw accel solid operation\n")); driver_priv = exaGetPixmapDriverPrivate(pPix); if (driver_priv) { info->state_2d.dst_bo = driver_priv->bo; info->state_2d.dst_domain = driver_priv->shared ? RADEON_GEM_DOMAIN_GTT : RADEON_GEM_DOMAIN_VRAM; } info->state_2d.default_sc_bottom_right = (RADEON_DEFAULT_SC_RIGHT_MAX | RADEON_DEFAULT_SC_BOTTOM_MAX); info->state_2d.dp_brush_bkgd_clr = 0x00000000; info->state_2d.dp_src_frgd_clr = 0xffffffff; info->state_2d.dp_src_bkgd_clr = 0x00000000; info->state_2d.dp_gui_master_cntl = (RADEON_GMC_DST_PITCH_OFFSET_CNTL | RADEON_GMC_BRUSH_SOLID_COLOR | (datatype << 8) | RADEON_GMC_SRC_DATATYPE_COLOR | RADEON_ROP[alu].pattern | RADEON_GMC_CLR_CMP_CNTL_DIS); info->state_2d.dp_brush_frgd_clr = fg; info->state_2d.dp_cntl = (RADEON_DST_X_LEFT_TO_RIGHT | RADEON_DST_Y_TOP_TO_BOTTOM); info->state_2d.dp_write_mask = pm; info->state_2d.dst_pitch_offset = dst_pitch_offset; info->state_2d.src_pitch_offset = 0; info->state_2d.src_bo = NULL; info->accel_state->dst_pix = pPix; Emit2DState(pScrn, RADEON_2D_EXA_SOLID); 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 Bool maliPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir, int ydir, int alu, Pixel planemask) { PrivPixmap *srcPrivPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pSrcPixmap); PrivPixmap *dstPrivPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pDstPixmap); IGNORE(pSrcPixmap); IGNORE(pDstPixmap); IGNORE(xdir); IGNORE(ydir); IGNORE(alu); IGNORE(planemask); if (srcPrivPixmap->isFrameBuffer && dstPrivPixmap->isFrameBuffer) { //if (srcPrivPixmap->frameBufferNumber != 0 || // srcPrivPixmap->frameBufferNumber != 0) //{ // ERROR_STR("%s: pSrcPixmap=%p (buffer# %d) pDstPixmap=%p (buffer# %d) xdir=%d ydir=%d alu=%x\n", // __FUNCTION__, pSrcPixmap, srcPrivPixmap->frameBufferNumber, pDstPixmap, dstPrivPixmap->frameBufferNumber, xdir, ydir, alu); //} SrcPixmap = pSrcPixmap; if (ge2d_fd < 0) { init_ge2d(); } return TRUE; } //if (srcPrivPixmap->mem_info && // dstPrivPixmap->mem_info) //{ // //if (srcPrivPixmap->mem_info->handle != UMP_INVALID_SECURE_ID && // // dstPrivPixmap->mem_info->handle != UMP_INVALID_SECURE_ID) // { // SrcPixmap = pSrcPixmap; // if (ge2d_fd < 0) // { // init_ge2d(); // } // return TRUE; // } //} return FALSE; }
static void ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY, int width, int height) { ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap); 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(priv == exa->copy.dst); (void) priv; if (exa->copy.use_surface_copy) { struct pipe_box src_box; u_box_2d(srcX, srcY, width, height, &src_box); exa->pipe->resource_copy_region( exa->pipe, exa->copy.dst->tex, 0, dstX, dstY, 0, exa->copy.src->tex, 0, &src_box); } else { renderer_copy_pixmap(exa->renderer, dstX, dstY, srcX, srcY, width, height, exa->copy.src_texture->width0, exa->copy.src_texture->height0); } }
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 = xf86Screens[pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix); struct pipe_transfer *transfer; if (!priv || !priv->tex) return FALSE; transfer = pipe_get_transfer(exa->pipe, priv->tex, 0, 0, PIPE_TRANSFER_READ, x, y, w, h); if (!transfer) 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, exa->pipe->transfer_map(exa->pipe, transfer), transfer->stride, 0, 0); exa->pipe->transfer_unmap(exa->pipe, transfer); exa->pipe->transfer_destroy(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 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); }
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 Bool XAPixmapIsOffscreen(PixmapPtr pPixmap) { ScreenPtr pScreen = pPixmap->drawable.pScreen; struct xa_surface *surf = msm_get_pixmap_surf(pPixmap); if ((pScreen->GetScreenPixmap(pScreen) == pPixmap)) { return TRUE; } if (!surf) { /* because we are pretending to handle unaccel (1bpp, etc) * pixmaps too.. * this is pretty lame, revisit using EXA_MIXED_PIXMAPS */ struct msm_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); if (priv && priv->ptr) { return TRUE; } } if (surf) return TRUE; return FALSE; }
static Bool RADEONPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int xdir, int ydir, int rop, Pixel planemask) { RINFO_FROM_SCREEN(pDst->drawable.pScreen); uint32_t datatype, src_pitch_offset, dst_pitch_offset; struct radeon_exa_pixmap_priv *driver_priv; int ret; TRACE; if (pDst->drawable.bitsPerPixel == 24) RADEON_FALLBACK(("24bpp unsupported")); if (!RADEONGetDatatypeBpp(pDst->drawable.bitsPerPixel, &datatype)) RADEON_FALLBACK(("RADEONGetDatatypeBpp failed\n")); if (!RADEONGetPixmapOffsetPitch(pSrc, &src_pitch_offset)) RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch source failed\n")); if (!RADEONGetPixmapOffsetPitch(pDst, &dst_pitch_offset)) RADEON_FALLBACK(("RADEONGetPixmapOffsetPitch dest failed\n")); RADEON_SWITCH_TO_2D(); radeon_cs_space_reset_bos(info->cs); driver_priv = exaGetPixmapDriverPrivate(pSrc); radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, RADEON_GEM_DOMAIN_GTT | RADEON_GEM_DOMAIN_VRAM, 0); info->state_2d.src_bo = driver_priv->bo; driver_priv = exaGetPixmapDriverPrivate(pDst); info->state_2d.dst_bo = driver_priv->bo; info->state_2d.dst_domain = driver_priv->shared ? RADEON_GEM_DOMAIN_GTT : RADEON_GEM_DOMAIN_VRAM; radeon_cs_space_add_persistent_bo(info->cs, driver_priv->bo, 0, info->state_2d.dst_domain); ret = radeon_cs_space_check(info->cs); if (ret) RADEON_FALLBACK(("Not enough RAM to hw accel copy operation\n")); info->accel_state->xdir = xdir; info->accel_state->ydir = ydir; info->accel_state->dst_pix = pDst; RADEONDoPrepareCopy(pScrn, src_pitch_offset, dst_pitch_offset, datatype, rop, planemask); return TRUE; }
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 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));
static void maliFinishAccess(PixmapPtr pPix, int index) { PrivPixmap *privPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pPix); mali_mem_info *mem_info; ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; MaliPtr fPtr = MALIPTR(pScrn); IGNORE(index); if (!privPixmap) { return; } if (!pPix) { return; } mem_info = privPixmap->mem_info; if (!privPixmap->isFrameBuffer) { int secure_id = 0; _lock_item_s item; secure_id = ump_secure_id_get(mem_info->handle); if (secure_id) { item.secure_id = secure_id; item.usage = _LOCK_ACCESS_CPU_WRITE; if (fPtr->fd_umplock > 0) { ioctl(fPtr->fd_umplock, LOCK_IOCTL_RELEASE, &item); } } if (privPixmap->refs == 1) { if (NULL != mem_info) { ump_mapped_pointer_release(mem_info->handle); } } } pPix->devPrivate.ptr = NULL; privPixmap->refs--; }
static void ExaDoneSolid(PixmapPtr pPixmap) { ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct exa_context *exa = ms->exa; if (!priv) return; xorg_composite_done(exa); }
/* used by DRI2 code to play buffer switcharoo */ void ARMSOCPixmapExchange(PixmapPtr a, PixmapPtr b) { struct ARMSOCPixmapPrivRec *apriv = exaGetPixmapDriverPrivate(a); struct ARMSOCPixmapPrivRec *bpriv = exaGetPixmapDriverPrivate(b); exchange(apriv->priv, bpriv->priv); exchange(apriv->bo, bpriv->bo); /* Ensure neither pixmap has a dmabuf fd attached to the bo if the * ext_access_cnt refcount is 0, as it will never be cleared. */ if (armsoc_bo_has_dmabuf(apriv->bo) && !apriv->ext_access_cnt) { armsoc_bo_clear_dmabuf(apriv->bo); /* Should only have to clear one dmabuf fd, otherwise the * refcount is wrong */ assert(!armsoc_bo_has_dmabuf(bpriv->bo)); } else if (armsoc_bo_has_dmabuf(bpriv->bo) && !bpriv->ext_access_cnt) { armsoc_bo_clear_dmabuf(bpriv->bo); assert(!armsoc_bo_has_dmabuf(apriv->bo)); } }
static Bool ExaPrepareAccess(PixmapPtr pPix, int index) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; 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); priv->map_transfer = pipe_get_transfer(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 ); if (!priv->map_transfer) #ifdef EXA_MIXED_PIXMAPS return FALSE; #else FatalError("failed to create transfer\n"); #endif pPix->devPrivate.ptr = exa->pipe->transfer_map(exa->pipe, priv->map_transfer); pPix->devKind = priv->map_transfer->stride; } priv->map_count++; exa_debug_printf("ExaPrepareAccess %d prepared\n", index); return TRUE; }
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"); }
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; }
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_TEXTURE_USAGE_DISPLAY_TARGET; return 0; }
static Bool ExaPixmapIsOffscreen(PixmapPtr pPixmap) { struct exa_pixmap_priv *priv; priv = exaGetPixmapDriverPrivate(pPixmap); if (!priv) return FALSE; if (priv->tex) return TRUE; return FALSE; }
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 Bool maliPixmapIsOffscreen(PixmapPtr pPix) { ScreenPtr pScreen = pPix->drawable.pScreen; PrivPixmap *privPixmap = (PrivPixmap *)exaGetPixmapDriverPrivate(pPix); if (pScreen->GetScreenPixmap(pScreen) == pPix) { return TRUE; } if (privPixmap) { return pPix->devPrivate.ptr ? FALSE : TRUE; } return FALSE; }
static void ExaDoneCopy(PixmapPtr pPixmap) { ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); struct exa_context *exa = ms->exa; if (!priv) return; renderer_draw_flush(exa->renderer); exa->copy.src = NULL; exa->copy.dst = NULL; pipe_surface_reference(&exa->copy.src_surface, NULL); pipe_surface_reference(&exa->copy.dst_surface, NULL); pipe_texture_reference(&exa->copy.src_texture, NULL); }
static void ExaSolid(PixmapPtr pPixmap, int x0, int y0, int x1, int y1) { ScrnInfoPtr pScrn = xf86Screens[pPixmap->drawable.pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPixmap); #if DEBUG_PRINT debug_printf("\tExaSolid(%d, %d, %d, %d)\n", x0, y0, x1, y1); #endif if (x0 == 0 && y0 == 0 && x1 == pPixmap->drawable.width && y1 == pPixmap->drawable.height) { exa->pipe->clear(exa->pipe, PIPE_CLEAR_COLOR, exa->solid_color, 0.0, 0); return; } xorg_solid(exa, priv, x0, y0, x1, y1) ; }
Bool sgx_exa_update_pixmap(PixmapPtr pPixmap, int width, int height, int depth, int bitsPerPixel, int pitch, PVR2DMEMINFO *mem_info) { ScreenPtr pScreen = pPixmap->drawable.pScreen; struct PVR2DPixmap *priv = exaGetPixmapDriverPrivate(pPixmap); Bool ret; ret = (*pScreen->ModifyPixmapHeader)(pPixmap, width, height, depth, bitsPerPixel, pitch, NULL); if (ret) { priv->pvr2dmem = mem_info; priv->shmaddr = mem_info->pBase; } return ret; }
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 ExaUploadToScreen(PixmapPtr pPix, int x, int y, int w, int h, char *src, int src_pitch) { ScreenPtr pScreen = pPix->drawable.pScreen; ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pPix); struct pipe_transfer *transfer; if (!priv || !priv->tex) return FALSE; /* make sure that any pending operations are flushed to hardware */ if (exa->pipe->is_texture_referenced(exa->pipe, priv->tex, 0, 0) & (PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE)) xorg_exa_flush(exa, 0, NULL); transfer = exa->scrn->get_tex_transfer(exa->scrn, priv->tex, 0, 0, 0, PIPE_TRANSFER_WRITE, x, y, w, h); if (!transfer) return FALSE; #if DEBUG_PRINT debug_printf("++++++ ExaUploadToScreen(%d, %d, %d, %d, %d)\n", x, y, w, h, src_pitch); #endif util_copy_rect(exa->scrn->transfer_map(exa->scrn, transfer), priv->tex->format, transfer->stride, 0, 0, w, h, (unsigned char*)src, src_pitch, 0, 0); exa->scrn->transfer_unmap(exa->scrn, transfer); exa->scrn->tex_transfer_destroy(transfer); return TRUE; }
Bool getDrawableInfo(DrawablePtr pDraw, PVR2DMEMINFO ** ppMemInfo, long *pXoff, long *pYoff) { PixmapPtr pPixmap = pDraw->type == DRAWABLE_WINDOW ? pDraw->pScreen-> GetWindowPixmap((WindowPtr) pDraw) : (PixmapPtr) pDraw; struct PVR2DPixmap *ppix = exaGetPixmapDriverPrivate(pPixmap); if (!ppix || !PVR2DValidate(pPixmap, ppix, TRUE)) return FALSE; *ppMemInfo = ppix->pvr2dmem; #ifdef COMPOSITE *pXoff = -pPixmap->screen_x + pPixmap->drawable.x; *pYoff = -pPixmap->screen_y + pPixmap->drawable.y; #else *pXoff = 0; *pYoff = 0; #endif return TRUE; }
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 ExaCopy(PixmapPtr pDstPixmap, int srcX, int srcY, int dstX, int dstY, int width, int height) { ScrnInfoPtr pScrn = xf86Screens[pDstPixmap->drawable.pScreen->myNum]; modesettingPtr ms = modesettingPTR(pScrn); struct exa_context *exa = ms->exa; struct exa_pixmap_priv *priv = exaGetPixmapDriverPrivate(pDstPixmap); #if DEBUG_PRINT debug_printf("\tExaCopy(srcx=%d, srcy=%d, dstX=%d, dstY=%d, w=%d, h=%d)\n", srcX, srcY, dstX, dstY, width, height); #endif debug_assert(priv == exa->copy.dst); (void) priv; if (exa->copy.use_surface_copy) { /* XXX: consider exposing >1 box in surface_copy interface. */ exa->pipe->surface_copy( exa->pipe, exa->copy.dst_surface, dstX, dstY, exa->copy.src_surface, srcX, srcY, width, height ); } else { renderer_copy_pixmap(exa->renderer, dstX, dstY, srcX, srcY, width, height, exa->copy.src_texture->width0, exa->copy.src_texture->height0); } }