Bool fbChangeWindowAttributes(WindowPtr pWin, unsigned long mask) { PixmapPtr pPixmap; if (mask & CWBackPixmap) { if (pWin->backgroundState == BackgroundPixmap) { pPixmap = pWin->background.pixmap; #ifdef FB_24_32BIT if (pPixmap->drawable.bitsPerPixel != pWin->drawable.bitsPerPixel) { pPixmap = fb24_32ReformatTile (pPixmap, pWin->drawable.bitsPerPixel); if (pPixmap) { (*pWin->drawable.pScreen->DestroyPixmap) (pWin->background.pixmap); pWin->background.pixmap = pPixmap; } } #endif if (FbEvenTile (pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel)) fbPadPixmap (pPixmap); } } if (mask & CWBorderPixmap) { if (pWin->borderIsPixel == FALSE) { pPixmap = pWin->border.pixmap; #ifdef FB_24_32BIT if (pPixmap->drawable.bitsPerPixel != pWin->drawable.bitsPerPixel) { pPixmap = fb24_32ReformatTile (pPixmap, pWin->drawable.bitsPerPixel); if (pPixmap) { (*pWin->drawable.pScreen->DestroyPixmap) (pWin->border.pixmap); pWin->border.pixmap = pPixmap; } } #endif if (FbEvenTile (pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel)) fbPadPixmap (pPixmap); } } return TRUE; }
static void fbFixupWindowPixmap(DrawablePtr pDrawable, PixmapPtr *ppPixmap) { PixmapPtr pPixmap = *ppPixmap; if (pPixmap->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { pPixmap = fb24_32ReformatTile(pPixmap, pDrawable->bitsPerPixel); if (!pPixmap) return; (*pDrawable->pScreen->DestroyPixmap) (*ppPixmap); *ppPixmap = pPixmap; } if (FbEvenTile(pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel)) fbPadPixmap(pPixmap); }
static void vivante_unaccel_fixup_tile(DrawablePtr pDraw, PixmapPtr *ppPix) { PixmapPtr pNew, pPixmap = *ppPix; if (pPixmap->drawable.bitsPerPixel != pDraw->bitsPerPixel) { vivante_prepare_drawable(&pPixmap->drawable, ACCESS_RO); pNew = fb24_32ReformatTile(pPixmap, pDraw->bitsPerPixel); vivante_finish_drawable(&pPixmap->drawable, ACCESS_RO); pDraw->pScreen->DestroyPixmap(pPixmap); *ppPix = pPixmap = pNew; } if (FbEvenTile(pPixmap->drawable.width * pPixmap->drawable.bitsPerPixel)) { vivante_prepare_drawable(&pPixmap->drawable, ACCESS_RW); fbPadPixmap(pPixmap); vivante_finish_drawable(&pPixmap->drawable, ACCESS_RW); } }
/** * exaValidateGC() sets the ops to EXA's implementations, which may be * accelerated or may sync the card and fall back to fb. */ static void exaValidateGC (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { /* fbValidateGC will do direct access to pixmaps if the tiling has changed. * Preempt fbValidateGC by doing its work and masking the change out, so * that we can do the Prepare/FinishAccess. */ #ifdef FB_24_32BIT if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) { (*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC)); fbGetRotatedPixmap(pGC) = 0; } if (pGC->fillStyle == FillTiled) { PixmapPtr pOldTile, pNewTile; pOldTile = pGC->tile.pixmap; if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { pNewTile = fbGetRotatedPixmap(pGC); if (!pNewTile || pNewTile ->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { if (pNewTile) (*pGC->pScreen->DestroyPixmap) (pNewTile); /* fb24_32ReformatTile will do direct access of a newly- * allocated pixmap. This isn't a problem yet, since we don't * put pixmaps in FB until at least one accelerated EXA op. */ exaPrepareAccess(&pOldTile->drawable, EXA_PREPARE_SRC); pNewTile = fb24_32ReformatTile (pOldTile, pDrawable->bitsPerPixel); exaPixmapDirty(pNewTile, 0, 0, pNewTile->drawable.width, pNewTile->drawable.height); exaFinishAccess(&pOldTile->drawable, EXA_PREPARE_SRC); } if (pNewTile) { fbGetRotatedPixmap(pGC) = pOldTile; pGC->tile.pixmap = pNewTile; changes |= GCTile; } } } #endif if (changes & GCTile) { if (!pGC->tileIsPixel && FbEvenTile (pGC->tile.pixmap->drawable.width * pDrawable->bitsPerPixel)) { /* XXX This fixes corruption with tiled pixmaps, but may just be a * workaround for broken drivers */ exaMoveOutPixmap(pGC->tile.pixmap); fbPadPixmap (pGC->tile.pixmap); exaPixmapDirty(pGC->tile.pixmap, 0, 0, pGC->tile.pixmap->drawable.width, pGC->tile.pixmap->drawable.height); } /* Mask out the GCTile change notification, now that we've done FB's * job for it. */ changes &= ~GCTile; } fbValidateGC (pGC, changes, pDrawable); pGC->ops = (GCOps *) &exaOps; }
void xglValidateGC (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { XGL_GC_PRIV (pGC); if (changes & GCTile) { if (!pGC->tileIsPixel && FbEvenTile (pGC->tile.pixmap->drawable.width * pDrawable->bitsPerPixel)) xglSyncBits (&pGC->tile.pixmap->drawable, NULL); } if (changes & GCStipple) { if (pGC->stipple) xglSyncBits (&pGC->stipple->drawable, NULL); } XGL_GC_UNWRAP (funcs); XGL_GC_UNWRAP (ops); (*pGC->funcs->ValidateGC) (pGC, changes, pDrawable); XGL_GC_WRAP (funcs, (GCFuncs *) &xglGCFuncs); XGL_GC_WRAP (ops, (GCOps *) &xglGCOps); if (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)) { XGL_DRAWABLE_PIXMAP_PRIV (pDrawable); if (pPixmapPriv->pVisual && pPixmapPriv->pVisual->format.surface) { glitz_format_t *format; format = pPixmapPriv->pVisual->format.surface; if (format->id != pGCPriv->id) { XGL_SCREEN_PRIV (pDrawable->pScreen); pGCPriv->flags |= xglGCSoftwareDrawableFlag; if (pGCPriv->fg) glitz_surface_destroy (pGCPriv->fg); pGCPriv->fg = glitz_surface_create (pScreenPriv->drawable, format, 1, 1, 0, NULL); if (pGCPriv->fg) glitz_surface_set_fill (pGCPriv->fg, GLITZ_FILL_REPEAT); if (pGCPriv->bg) glitz_surface_destroy (pGCPriv->bg); pGCPriv->bg = glitz_surface_create (pScreenPriv->drawable, format, 1, 1, 0, NULL); if (pGCPriv->bg) glitz_surface_set_fill (pGCPriv->bg, GLITZ_FILL_REPEAT); pGCPriv->id = format->id; if (pGCPriv->fg && pGCPriv->bg) { changes |= (GCForeground | GCBackground); pGCPriv->flags &= ~xglGCSoftwareDrawableFlag; } } } else pGCPriv->flags |= xglGCSoftwareDrawableFlag; } if (changes & GCFunction) { switch (pGC->alu) { case GXclear: pGCPriv->op = GLITZ_OPERATOR_CLEAR; pGCPriv->flags &= ~xglGCBadFunctionFlag; break; case GXcopy: pGCPriv->op = GLITZ_OPERATOR_SRC; pGCPriv->flags &= ~xglGCBadFunctionFlag; break; case GXnoop: pGCPriv->op = GLITZ_OPERATOR_DST; pGCPriv->flags &= ~xglGCBadFunctionFlag; break; default: pGCPriv->flags |= xglGCBadFunctionFlag; break; } } if (changes & GCPlaneMask) { FbBits mask; mask = FbFullMask (pDrawable->depth); if ((pGC->planemask & mask) != mask) pGCPriv->flags |= xglGCPlaneMaskFlag; else pGCPriv->flags &= ~xglGCPlaneMaskFlag; } if (!(pGCPriv->flags & xglGCSoftwareDrawableFlag)) { if (changes & (GCForeground | GCBackground)) { glitz_pixel_format_t format; glitz_buffer_t *buffer; CARD32 pixel; XGL_DRAWABLE_PIXMAP_PRIV (pDrawable); format.fourcc = GLITZ_FOURCC_RGB; format.masks = pPixmapPriv->pVisual->pPixel->masks; format.xoffset = 0; format.skip_lines = 0; format.bytes_per_line = sizeof (CARD32); format.scanline_order = GLITZ_PIXEL_SCANLINE_ORDER_BOTTOM_UP; buffer = glitz_buffer_create_for_data (&pixel); if (changes & GCForeground) { pixel = pGC->fgPixel; glitz_set_pixels (pGCPriv->fg, 0, 0, 1, 1, &format, buffer); } if (changes & GCBackground) { pixel = pGC->bgPixel; glitz_set_pixels (pGCPriv->bg, 0, 0, 1, 1, &format, buffer); } glitz_buffer_destroy (buffer); } } }
/** * uxa_validate_gc() sets the ops to UXA's implementations, which may be * accelerated or may sync the card and fall back to fb. */ static void uxa_validate_gc(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { /* fbValidateGC will do direct access to pixmaps if the tiling has * changed. * Preempt fbValidateGC by doing its work and masking the change out, so * that we can do the Prepare/finish_access. */ #ifdef FB_24_32BIT if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) { (*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC)); fbGetRotatedPixmap(pGC) = 0; } if (pGC->fillStyle == FillTiled) { PixmapPtr pOldTile, pNewTile; pOldTile = pGC->tile.pixmap; if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { pNewTile = fbGetRotatedPixmap(pGC); if (!pNewTile || pNewTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { if (pNewTile) (*pGC->pScreen-> DestroyPixmap) (pNewTile); /* fb24_32ReformatTile will do direct access * of a newly-allocated pixmap. This isn't a * problem yet, since we don't put pixmaps in * FB until at least one accelerated UXA op. */ if (uxa_prepare_access (&pOldTile->drawable, NULL, UXA_ACCESS_RO)) { pNewTile = fb24_32ReformatTile(pOldTile, pDrawable-> bitsPerPixel); uxa_finish_access(&pOldTile->drawable); } } if (pNewTile) { fbGetRotatedPixmap(pGC) = pOldTile; pGC->tile.pixmap = pNewTile; changes |= GCTile; } } } #endif if (changes & GCTile) { if (!pGC->tileIsPixel && FbEvenTile(pGC->tile.pixmap->drawable.width * pDrawable->bitsPerPixel)) { if (uxa_prepare_access (&pGC->tile.pixmap->drawable, NULL, UXA_ACCESS_RW)) { fbPadPixmap(pGC->tile.pixmap); uxa_finish_access(&pGC->tile.pixmap->drawable); } } /* Mask out the GCTile change notification, now that we've * done FB's job for it. */ changes &= ~GCTile; } if (changes & GCStipple && pGC->stipple) { /* We can't inline stipple handling like we do for GCTile * because it sets fbgc privates. */ if (uxa_prepare_access(&pGC->stipple->drawable, NULL, UXA_ACCESS_RW)) { fbValidateGC(pGC, changes, pDrawable); uxa_finish_access(&pGC->stipple->drawable); } } else { fbValidateGC(pGC, changes, pDrawable); } pGC->ops = (GCOps *) & uxa_ops; }
void fbValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); FbBits mask; /* * if the client clip is different or moved OR the subwindowMode has * changed OR the window's clip has changed since the last validation * we need to recompute the composite clip */ if ((changes & (GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)) ) { miComputeCompositeClip(pGC, pDrawable); } if (pPriv->bpp != pDrawable->bitsPerPixel) { changes |= GCStipple | GCForeground | GCBackground | GCPlaneMask; pPriv->bpp = pDrawable->bitsPerPixel; } if ((changes & GCTile) && fbGetRotatedPixmap(pGC)) { (*pGC->pScreen->DestroyPixmap) (fbGetRotatedPixmap(pGC)); fbGetRotatedPixmap(pGC) = 0; } if (pGC->fillStyle == FillTiled) { PixmapPtr pOldTile, pNewTile; pOldTile = pGC->tile.pixmap; if (pOldTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { pNewTile = fbGetRotatedPixmap(pGC); if (!pNewTile || pNewTile->drawable.bitsPerPixel != pDrawable->bitsPerPixel) { if (pNewTile) (*pGC->pScreen->DestroyPixmap) (pNewTile); pNewTile = fb24_32ReformatTile(pOldTile, pDrawable->bitsPerPixel); } if (pNewTile) { fbGetRotatedPixmap(pGC) = pOldTile; pGC->tile.pixmap = pNewTile; changes |= GCTile; } } } if (changes & GCTile) { if (!pGC->tileIsPixel && FbEvenTile(pGC->tile.pixmap->drawable.width * pDrawable->bitsPerPixel)) fbPadPixmap(pGC->tile.pixmap); } if (changes & GCStipple) { pPriv->evenStipple = FALSE; if (pGC->stipple) { /* can we do an even stipple ?? */ if (FbEvenStip(pGC->stipple->drawable.width, pDrawable->bitsPerPixel) && (fbCanEvenStipple(pGC->stipple, pDrawable->bitsPerPixel))) pPriv->evenStipple = TRUE; if (pGC->stipple->drawable.width * pDrawable->bitsPerPixel < FB_UNIT) fbPadPixmap(pGC->stipple); } } /* * Recompute reduced rop values */ if (changes & (GCForeground | GCBackground | GCPlaneMask | GCFunction)) { int s; FbBits depthMask; mask = FbFullMask(pDrawable->bitsPerPixel); depthMask = FbFullMask(pDrawable->depth); pPriv->fg = pGC->fgPixel & mask; pPriv->bg = pGC->bgPixel & mask; if ((pGC->planemask & depthMask) == depthMask) pPriv->pm = mask; else pPriv->pm = pGC->planemask & mask; s = pDrawable->bitsPerPixel; while (s < FB_UNIT) { pPriv->fg |= pPriv->fg << s; pPriv->bg |= pPriv->bg << s; pPriv->pm |= pPriv->pm << s; s <<= 1; } pPriv->and = fbAnd(pGC->alu, pPriv->fg, pPriv->pm); pPriv->xor = fbXor(pGC->alu, pPriv->fg, pPriv->pm); pPriv->bgand = fbAnd(pGC->alu, pPriv->bg, pPriv->pm); pPriv->bgxor = fbXor(pGC->alu, pPriv->bg, pPriv->pm); } if (changes & GCDashList) { unsigned short n = pGC->numInDashList; unsigned char *dash = pGC->dash; unsigned int dashLength = 0; while (n--) dashLength += (unsigned int) *dash++; pPriv->dashLength = dashLength; } }
/** * uxa_validate_gc() sets the ops to glamor's implementations, which may be * accelerated or may sync the card and fall back to fb. */ void glamor_validate_gc(GCPtr gc, unsigned long changes, DrawablePtr drawable) { /* fbValidateGC will do direct access to pixmaps if the tiling has changed. * Preempt fbValidateGC by doing its work and masking the change out, so * that we can do the Prepare/finish_access. */ #ifdef FB_24_32BIT if ((changes & GCTile) && fbGetRotatedPixmap(gc)) { gc->pScreen->DestroyPixmap(fbGetRotatedPixmap(gc)); fbGetRotatedPixmap(gc) = 0; } if (gc->fillStyle == FillTiled) { PixmapPtr old_tile, new_tile; old_tile = gc->tile.pixmap; if (old_tile->drawable.bitsPerPixel != drawable->bitsPerPixel) { new_tile = fbGetRotatedPixmap(gc); if (!new_tile || new_tile->drawable.bitsPerPixel != drawable->bitsPerPixel) { if (new_tile) gc->pScreen->DestroyPixmap(new_tile); /* fb24_32ReformatTile will do direct access of a newly- * allocated pixmap. */ glamor_fallback ("GC %p tile FB_24_32 transformat %p.\n", gc, old_tile); if (glamor_prepare_access (&old_tile->drawable, GLAMOR_ACCESS_RO)) { new_tile = fb24_32ReformatTile(old_tile, drawable->bitsPerPixel); glamor_finish_access(&old_tile->drawable, GLAMOR_ACCESS_RO); } } if (new_tile) { fbGetRotatedPixmap(gc) = old_tile; gc->tile.pixmap = new_tile; changes |= GCTile; } } } #endif if (changes & GCTile) { if (!gc->tileIsPixel) { glamor_pixmap_private *pixmap_priv = glamor_get_pixmap_private(gc->tile.pixmap); if ((!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv)) && FbEvenTile(gc->tile.pixmap->drawable.width * drawable->bitsPerPixel)) { glamor_fallback ("GC %p tile changed %p.\n", gc, gc->tile.pixmap); if (glamor_prepare_access (&gc->tile.pixmap->drawable, GLAMOR_ACCESS_RW)) { fbPadPixmap(gc->tile.pixmap); glamor_finish_access (&gc->tile.pixmap->drawable, GLAMOR_ACCESS_RW); } } } /* Mask out the GCTile change notification, now that we've done FB's * job for it. */ changes &= ~GCTile; } if (changes & GCStipple && gc->stipple) { /* We can't inline stipple handling like we do for GCTile because * it sets fbgc privates. */ if (glamor_prepare_access(&gc->stipple->drawable, GLAMOR_ACCESS_RW)) { fbValidateGC(gc, changes, drawable); glamor_finish_access(&gc->stipple->drawable, GLAMOR_ACCESS_RW); } } else { fbValidateGC(gc, changes, drawable); } gc->ops = &glamor_gc_ops; }
void fbValidateGC(GCPtr pGC, unsigned long changes, DrawablePtr pDrawable) { FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); FbBits mask; /* * if the client clip is different or moved OR the subwindowMode has * changed OR the window's clip has changed since the last validation * we need to recompute the composite clip */ if ((changes & (GCClipXOrigin | GCClipYOrigin | GCClipMask | GCSubwindowMode)) || (pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS)) ) { miComputeCompositeClip(pGC, pDrawable); } if (changes & GCTile) { if (!pGC->tileIsPixel && FbEvenTile(pGC->tile.pixmap->drawable.width * pDrawable->bitsPerPixel)) fbPadPixmap(pGC->tile.pixmap); } if (changes & GCStipple) { if (pGC->stipple) { if (pGC->stipple->drawable.width * pDrawable->bitsPerPixel < FB_UNIT) fbPadPixmap(pGC->stipple); } } /* * Recompute reduced rop values */ if (changes & (GCForeground | GCBackground | GCPlaneMask | GCFunction)) { int s; FbBits depthMask; mask = FbFullMask(pDrawable->bitsPerPixel); depthMask = FbFullMask(pDrawable->depth); pPriv->fg = pGC->fgPixel & mask; pPriv->bg = pGC->bgPixel & mask; if ((pGC->planemask & depthMask) == depthMask) pPriv->pm = mask; else pPriv->pm = pGC->planemask & mask; s = pDrawable->bitsPerPixel; while (s < FB_UNIT) { pPriv->fg |= pPriv->fg << s; pPriv->bg |= pPriv->bg << s; pPriv->pm |= pPriv->pm << s; s <<= 1; } pPriv->and = fbAnd(pGC->alu, pPriv->fg, pPriv->pm); pPriv->xor = fbXor(pGC->alu, pPriv->fg, pPriv->pm); pPriv->bgand = fbAnd(pGC->alu, pPriv->bg, pPriv->pm); pPriv->bgxor = fbXor(pGC->alu, pPriv->bg, pPriv->pm); } if (changes & GCDashList) { unsigned short n = pGC->numInDashList; unsigned char *dash = pGC->dash; unsigned int dashLength = 0; while (n--) dashLength += (unsigned int) *dash++; pPriv->dashLength = dashLength; } }