diff --git a/hw/kdrive/fbdev/fbdev.c b/hw/kdrive/fbdev/fbdev.c index d6fcf1a5f..95f64cbef 100644 --- a/hw/kdrive/fbdev/fbdev.c +++ b/hw/kdrive/fbdev/fbdev.c @@ -30,7 +30,7 @@ extern int KdTsPhyScreen; -char *fbdevDevicePath = NULL; +const char *fbdevDevicePath = NULL; static Bool fbdevInitialize(KdCardInfo * card, FbdevPriv * priv) @@ -206,13 +206,23 @@ fbdevScreenInitialize(KdScreenInfo * screen, FbdevScrPriv * scrpriv) depth = priv->var.bits_per_pixel; gray = priv->var.grayscale; + /* Calculate fix.line_length if it's zero */ + if (!priv->fix.line_length) + priv->fix.line_length = (priv->var.xres_virtual * depth + 7) / 8; + switch (priv->fix.visual) { + case FB_VISUAL_MONO01: + case FB_VISUAL_MONO10: + screen->fb.visuals = (1 << StaticGray); + break; case FB_VISUAL_PSEUDOCOLOR: - if (gray) { - screen->fb.visuals = (1 << StaticGray); + screen->fb.visuals = (1 << StaticGray); + if (priv->var.bits_per_pixel == 1) { + /* Override to monochrome, to have preallocated black/white */ + priv->fix.visual = FB_VISUAL_MONO01; + } else if (gray) { /* could also support GrayScale, but what's the point? */ - } - else { + } else { screen->fb.visuals = ((1 << StaticGray) | (1 << GrayScale) | (1 << StaticColor) | @@ -309,6 +319,21 @@ fbdevWindowLinear(ScreenPtr pScreen, return (CARD8 *) priv->fb + row * priv->fix.line_length + offset; } +static void * +fbdevWindowAfb(ScreenPtr pScreen, + CARD32 row, + CARD32 offset, int mode, CARD32 *size, void *closure) +{ + KdScreenPriv(pScreen); + FbdevPriv *priv = pScreenPriv->card->driver; + + if (!pScreenPriv->enabled) + return 0; + /* offset to next plane */ + *size = priv->var.yres_virtual * priv->fix.line_length; + return (CARD8 *) priv->fb + row * priv->fix.line_length + offset; +} + Bool fbdevMapFramebuffer(KdScreenInfo * screen) { @@ -316,7 +341,8 @@ fbdevMapFramebuffer(KdScreenInfo * screen) KdPointerMatrix m; FbdevPriv *priv = screen->card->driver; - if (scrpriv->randr != RR_Rotate_0) + if (scrpriv->randr != RR_Rotate_0 || + priv->fix.type != FB_TYPE_PACKED_PIXELS) scrpriv->shadow = TRUE; else scrpriv->shadow = FALSE; @@ -392,33 +418,88 @@ fbdevSetShadow(ScreenPtr pScreen) window = fbdevWindowLinear; update = 0; - if (scrpriv->randr) - if (priv->var.bits_per_pixel == 16) { - switch (scrpriv->randr) { - case RR_Rotate_90: - if (useYX) - update = shadowUpdateRotate16_90YX; - else - update = shadowUpdateRotate16_90; - break; - case RR_Rotate_180: - update = shadowUpdateRotate16_180; - break; - case RR_Rotate_270: - if (useYX) - update = shadowUpdateRotate16_270YX; - else - update = shadowUpdateRotate16_270; - break; - default: - update = shadowUpdateRotate16; - break; + switch (priv->fix.type) { + case FB_TYPE_PACKED_PIXELS: + if (scrpriv->randr) + if (priv->var.bits_per_pixel == 16) { + switch (scrpriv->randr) { + case RR_Rotate_90: + if (useYX) + update = shadowUpdateRotate16_90YX; + else + update = shadowUpdateRotate16_90; + break; + case RR_Rotate_180: + update = shadowUpdateRotate16_180; + break; + case RR_Rotate_270: + if (useYX) + update = shadowUpdateRotate16_270YX; + else + update = shadowUpdateRotate16_270; + break; + default: + update = shadowUpdateRotate16; + break; + } } - } + else + update = shadowUpdateRotatePacked; else - update = shadowUpdateRotatePacked; - else - update = shadowUpdatePacked; + update = shadowUpdatePacked; + break; + + case FB_TYPE_PLANES: + window = fbdevWindowAfb; + switch (priv->var.bits_per_pixel) { + case 4: + update = shadowUpdateAfb4; + break; + + case 8: + update = shadowUpdateAfb8; + break; + + default: + FatalError("Bitplanes with bpp %u are not yet supported\n", + priv->var.bits_per_pixel); + } + break; + + case FB_TYPE_INTERLEAVED_PLANES: + if (priv->fix.type_aux == 2) { + switch (priv->var.bits_per_pixel) { + case 4: + update = shadowUpdateIplan2p4; + break; + + case 8: + update = shadowUpdateIplan2p8; + break; + + default: + FatalError("Atari interleaved bitplanes with bpp %u are not yet supported\n", + priv->var.bits_per_pixel); + } + } else { + FatalError("Interleaved bitplanes with interleave %u are not yet supported\n", + priv->fix.type_aux); + } + break; + + case FB_TYPE_TEXT: + FatalError("Text frame buffers are not yet supported\n"); + break; + + case FB_TYPE_VGA_PLANES: + FatalError("VGA planes are not yet supported\n"); + break; + + default: + FatalError("Unsupported frame buffer type %u\n", priv->fix.type); + break; + } + return KdShadowSet(pScreen, scrpriv->randr, update, window); } @@ -573,6 +654,26 @@ fbdevCreateColormap(ColormapPtr pmap) xColorItem *pdefs; switch (priv->fix.visual) { + case FB_VISUAL_MONO01: + pScreen->whitePixel = 0; + pScreen->blackPixel = 1; + pmap->red[0].co.local.red = 65535; + pmap->red[0].co.local.green = 65535; + pmap->red[0].co.local.blue = 65535; + pmap->red[1].co.local.red = 0; + pmap->red[1].co.local.green = 0; + pmap->red[1].co.local.blue = 0; + return TRUE; + case FB_VISUAL_MONO10: + pScreen->blackPixel = 0; + pScreen->whitePixel = 1; + pmap->red[0].co.local.red = 0; + pmap->red[0].co.local.green = 0; + pmap->red[0].co.local.blue = 0; + pmap->red[1].co.local.red = 65535; + pmap->red[1].co.local.green = 65535; + pmap->red[1].co.local.blue = 65535; + return TRUE; case FB_VISUAL_STATIC_PSEUDOCOLOR: pVisual = pmap->pVisual; nent = pVisual->ColormapEntries; diff --git a/hw/kdrive/fbdev/fbdev.h b/hw/kdrive/fbdev/fbdev.h index 0706f4e11..f3f7aeceb 100644 --- a/hw/kdrive/fbdev/fbdev.h +++ b/hw/kdrive/fbdev/fbdev.h @@ -49,7 +49,7 @@ typedef struct _fbdevScrPriv { } FbdevScrPriv; extern KdCardFuncs fbdevFuncs; -extern char *fbdevDevicePath; +extern const char *fbdevDevicePath; Bool fbdevCardInit(KdCardInfo * card); diff --git a/hw/kdrive/src/kdrive.c b/hw/kdrive/src/kdrive.c index 7d9bf9ddd..1899a27a9 100644 --- a/hw/kdrive/src/kdrive.c +++ b/hw/kdrive/src/kdrive.c @@ -943,7 +943,8 @@ KdInitScreen(ScreenInfo * pScreenInfo, { KdCardInfo *card = screen->card; - (*card->cfuncs->scrinit) (screen); + if (!(*card->cfuncs->scrinit) (screen)) + FatalError("Screen initialization failed!\n"); if (!card->cfuncs->initAccel) screen->dumb = TRUE; diff --git a/miext/shadow/Makefile.am b/miext/shadow/Makefile.am index 30f7bda96..1db8a26b4 100644 --- a/miext/shadow/Makefile.am +++ b/miext/shadow/Makefile.am @@ -9,7 +9,11 @@ endif libshadow_la_SOURCES = \ shadow.c \ shadow.h \ + shafb4.c \ + shafb8.c \ shalloc.c \ + shiplan2p4.c \ + shiplan2p8.c \ shpacked.c \ shplanar8.c \ shplanar.c \ diff --git a/miext/shadow/c2p_core.h b/miext/shadow/c2p_core.h new file mode 100644 index 000000000..252f93ea7 --- /dev/null +++ b/miext/shadow/c2p_core.h @@ -0,0 +1,184 @@ +/* + * Fast C2P (Chunky-to-Planar) Conversion + * + * Copyright (C) 2003-2008 Geert Uytterhoeven + * + * NOTES: + * - This code was inspired by Scout's C2P tutorial + * - It assumes to run on a big endian system + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Geert Uytterhoeven not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Geert Uytterhoeven makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * GEERT UYTTERHOEVEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL GEERT UYTTERHOEVEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + */ + + + /* + * Basic transpose step + */ + +static inline void _transp(CARD32 d[], unsigned int i1, unsigned int i2, + unsigned int shift, CARD32 mask) +{ + CARD32 t = (d[i1] ^ (d[i2] >> shift)) & mask; + + d[i1] ^= t; + d[i2] ^= t << shift; +} + + +extern void c2p_unsupported(void); + +static inline CARD32 get_mask(unsigned int n) +{ + switch (n) { + case 1: + return 0x55555555; + + case 2: + return 0x33333333; + + case 4: + return 0x0f0f0f0f; + + case 8: + return 0x00ff00ff; + + case 16: + return 0x0000ffff; + } + + c2p_unsupported(); + return 0; +} + + + /* + * Transpose operations on 8 32-bit words + */ + +static inline void transp8(CARD32 d[], unsigned int n, unsigned int m) +{ + CARD32 mask = get_mask(n); + + switch (m) { + case 1: + /* First n x 1 block */ + _transp(d, 0, 1, n, mask); + /* Second n x 1 block */ + _transp(d, 2, 3, n, mask); + /* Third n x 1 block */ + _transp(d, 4, 5, n, mask); + /* Fourth n x 1 block */ + _transp(d, 6, 7, n, mask); + return; + + case 2: + /* First n x 2 block */ + _transp(d, 0, 2, n, mask); + _transp(d, 1, 3, n, mask); + /* Second n x 2 block */ + _transp(d, 4, 6, n, mask); + _transp(d, 5, 7, n, mask); + return; + + case 4: + /* Single n x 4 block */ + _transp(d, 0, 4, n, mask); + _transp(d, 1, 5, n, mask); + _transp(d, 2, 6, n, mask); + _transp(d, 3, 7, n, mask); + return; + } + + c2p_unsupported(); +} + + + /* + * Transpose operations on 4 32-bit words + */ + +static inline void transp4(CARD32 d[], unsigned int n, unsigned int m) +{ + CARD32 mask = get_mask(n); + + switch (m) { + case 1: + /* First n x 1 block */ + _transp(d, 0, 1, n, mask); + /* Second n x 1 block */ + _transp(d, 2, 3, n, mask); + return; + + case 2: + /* Single n x 2 block */ + _transp(d, 0, 2, n, mask); + _transp(d, 1, 3, n, mask); + return; + } + + c2p_unsupported(); +} + + + /* + * Transpose operations on 4 32-bit words (reverse order) + */ + +static inline void transp4x(CARD32 d[], unsigned int n, unsigned int m) +{ + CARD32 mask = get_mask(n); + + switch (m) { + case 2: + /* Single n x 2 block */ + _transp(d, 2, 0, n, mask); + _transp(d, 3, 1, n, mask); + return; + } + + c2p_unsupported(); +} + + + /* + * Transpose operations on 2 32-bit words + */ + +static inline void transp2(CARD32 d[], unsigned int n) +{ + CARD32 mask = get_mask(n); + + /* Single n x 1 block */ + _transp(d, 0, 1, n, mask); + return; +} + + + /* + * Transpose operations on 2 32-bit words (reverse order) + */ + +static inline void transp2x(CARD32 d[], unsigned int n) +{ + CARD32 mask = get_mask(n); + + /* Single n x 1 block */ + _transp(d, 1, 0, n, mask); + return; +} diff --git a/miext/shadow/shadow.h b/miext/shadow/shadow.h index 83de22ccc..421ae96a6 100644 --- a/miext/shadow/shadow.h +++ b/miext/shadow/shadow.h @@ -95,6 +95,18 @@ shadowInit(ScreenPtr pScreen, ShadowUpdateProc update, ShadowWindowProc window); extern _X_EXPORT void *shadowAlloc(int width, int height, int bpp); +extern _X_EXPORT void + shadowUpdateAfb4(ScreenPtr pScreen, shadowBufPtr pBuf); + +extern _X_EXPORT void + shadowUpdateAfb8(ScreenPtr pScreen, shadowBufPtr pBuf); + +extern _X_EXPORT void + shadowUpdateIplan2p4(ScreenPtr pScreen, shadowBufPtr pBuf); + +extern _X_EXPORT void + shadowUpdateIplan2p8(ScreenPtr pScreen, shadowBufPtr pBuf); + extern _X_EXPORT void shadowUpdatePacked(ScreenPtr pScreen, shadowBufPtr pBuf); diff --git a/miext/shadow/shafb4.c b/miext/shadow/shafb4.c new file mode 100644 index 000000000..07249323a --- /dev/null +++ b/miext/shadow/shafb4.c @@ -0,0 +1,139 @@ +/* + * + * Copyright © 2013 Geert Uytterhoeven + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Geert Uytterhoeven not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Geert Uytterhoeven makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * GEERT UYTTERHOEVEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL GEERT UYTTERHOEVEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Based on shpacked.c, which is Copyright © 2000 Keith Packard + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include + +#include +#include "scrnintstr.h" +#include "windowstr.h" +#include +#include "dixfontstr.h" +#include +#include "mi.h" +#include "regionstr.h" +#include "globals.h" +#include "gcstruct.h" +#include "shadow.h" +#include "fb.h" +#include "c2p_core.h" + + + /* + * Perform a full C2P step on 32 4-bit pixels, stored in 4 32-bit words + * containing + * - 32 4-bit chunky pixels on input + * - permutated planar data (1 plane per 32-bit word) on output + */ + +static void c2p_32x4(CARD32 d[4]) +{ + transp4(d, 16, 2); + transp4(d, 8, 1); + transp4(d, 4, 2); + transp4(d, 2, 1); + transp4(d, 1, 2); +} + + + /* + * Store a full block of permutated planar data after c2p conversion + */ + +static inline void store_afb4(void *dst, unsigned int stride, + const CARD32 d[4]) +{ + CARD8 *p = dst; + + *(CARD32 *)p = d[3]; p += stride; + *(CARD32 *)p = d[1]; p += stride; + *(CARD32 *)p = d[2]; p += stride; + *(CARD32 *)p = d[0]; p += stride; +} + + +void +shadowUpdateAfb4(ScreenPtr pScreen, shadowBufPtr pBuf) +{ + RegionPtr damage = shadowDamage(pBuf); + PixmapPtr pShadow = pBuf->pPixmap; + int nbox = RegionNumRects(damage); + BoxPtr pbox = RegionRects(damage); + FbBits *shaBase; + CARD32 *shaLine, *sha; + FbStride shaStride; + int scrLine; + _X_UNUSED int shaBpp, shaXoff, shaYoff; + int x, y, w, h; + int i, n; + CARD32 *win; + CARD32 off, winStride; + union { + CARD8 bytes[16]; + CARD32 words[4]; + } d; + + fbGetDrawable(&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, + shaYoff); + if (sizeof(FbBits) != sizeof(CARD32)) + shaStride = shaStride * sizeof(FbBits) / sizeof(CARD32); + + while (nbox--) { + x = pbox->x1; + y = pbox->y1; + w = pbox->x2 - pbox->x1; + h = pbox->y2 - pbox->y1; + + scrLine = (x & -32) / 2; + shaLine = (CARD32 *)shaBase + y * shaStride + scrLine / sizeof(CARD32); + + off = scrLine / 4; /* byte offset in bitplane scanline */ + n = ((x & 31) + w + 31) / 32; /* number of c2p units in scanline */ + + while (h--) { + sha = shaLine; + win = (CARD32 *) (*pBuf->window) (pScreen, + y, + off, + SHADOW_WINDOW_WRITE, + &winStride, + pBuf->closure); + if (!win) + return; + for (i = 0; i < n; i++) { + memcpy(d.bytes, sha, sizeof(d.bytes)); + c2p_32x4(d.words); + store_afb4(win++, winStride, d.words); + sha += sizeof(d.bytes) / sizeof(*sha); + } + shaLine += shaStride; + y++; + } + pbox++; + } +} diff --git a/miext/shadow/shafb8.c b/miext/shadow/shafb8.c new file mode 100644 index 000000000..0835e1650 --- /dev/null +++ b/miext/shadow/shafb8.c @@ -0,0 +1,143 @@ +/* + * + * Copyright © 2013 Geert Uytterhoeven + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Geert Uytterhoeven not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Geert Uytterhoeven makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * GEERT UYTTERHOEVEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL GEERT UYTTERHOEVEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Based on shpacked.c, which is Copyright © 2000 Keith Packard + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include + +#include +#include "scrnintstr.h" +#include "windowstr.h" +#include +#include "dixfontstr.h" +#include +#include "mi.h" +#include "regionstr.h" +#include "globals.h" +#include "gcstruct.h" +#include "shadow.h" +#include "fb.h" +#include "c2p_core.h" + + + /* + * Perform a full C2P step on 32 8-bit pixels, stored in 8 32-bit words + * containing + * - 32 8-bit chunky pixels on input + * - permutated planar data (1 plane per 32-bit word) on output + */ + +static void c2p_32x8(CARD32 d[8]) +{ + transp8(d, 16, 4); + transp8(d, 8, 2); + transp8(d, 4, 1); + transp8(d, 2, 4); + transp8(d, 1, 2); +} + + + /* + * Store a full block of permutated planar data after c2p conversion + */ + +static inline void store_afb8(void *dst, unsigned int stride, + const CARD32 d[8]) +{ + CARD8 *p = dst; + + *(CARD32 *)p = d[7]; p += stride; + *(CARD32 *)p = d[5]; p += stride; + *(CARD32 *)p = d[3]; p += stride; + *(CARD32 *)p = d[1]; p += stride; + *(CARD32 *)p = d[6]; p += stride; + *(CARD32 *)p = d[4]; p += stride; + *(CARD32 *)p = d[2]; p += stride; + *(CARD32 *)p = d[0]; p += stride; +} + + +void +shadowUpdateAfb8(ScreenPtr pScreen, shadowBufPtr pBuf) +{ + RegionPtr damage = shadowDamage(pBuf); + PixmapPtr pShadow = pBuf->pPixmap; + int nbox = RegionNumRects(damage); + BoxPtr pbox = RegionRects(damage); + FbBits *shaBase; + CARD32 *shaLine, *sha; + FbStride shaStride; + int scrLine; + _X_UNUSED int shaBpp, shaXoff, shaYoff; + int x, y, w, h; + int i, n; + CARD32 *win; + CARD32 off, winStride; + union { + CARD8 bytes[32]; + CARD32 words[8]; + } d; + + fbGetDrawable(&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, + shaYoff); + if (sizeof(FbBits) != sizeof(CARD32)) + shaStride = shaStride * sizeof(FbBits) / sizeof(CARD32); + + while (nbox--) { + x = pbox->x1; + y = pbox->y1; + w = pbox->x2 - pbox->x1; + h = pbox->y2 - pbox->y1; + + scrLine = x & -32; + shaLine = (CARD32 *)shaBase + y * shaStride + scrLine / sizeof(CARD32); + + off = scrLine / 8; /* byte offset in bitplane scanline */ + n = ((x & 31) + w + 31) / 32; /* number of c2p units in scanline */ + + while (h--) { + sha = shaLine; + win = (CARD32 *) (*pBuf->window) (pScreen, + y, + off, + SHADOW_WINDOW_WRITE, + &winStride, + pBuf->closure); + if (!win) + return; + for (i = 0; i < n; i++) { + memcpy(d.bytes, sha, sizeof(d.bytes)); + c2p_32x8(d.words); + store_afb8(win++, winStride, d.words); + sha += sizeof(d.bytes) / sizeof(*sha); + } + shaLine += shaStride; + y++; + } + pbox++; + } +} diff --git a/miext/shadow/shiplan2p4.c b/miext/shadow/shiplan2p4.c new file mode 100644 index 000000000..79ada99a4 --- /dev/null +++ b/miext/shadow/shiplan2p4.c @@ -0,0 +1,136 @@ +/* + * + * Copyright © 2013 Geert Uytterhoeven + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Geert Uytterhoeven not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Geert Uytterhoeven makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * GEERT UYTTERHOEVEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL GEERT UYTTERHOEVEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Based on shpacked.c, which is Copyright © 2000 Keith Packard + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include + +#include +#include "scrnintstr.h" +#include "windowstr.h" +#include +#include "dixfontstr.h" +#include +#include "mi.h" +#include "regionstr.h" +#include "globals.h" +#include "gcstruct.h" +#include "shadow.h" +#include "fb.h" +#include "c2p_core.h" + + + /* + * Perform a full C2P step on 16 4-bit pixels, stored in 2 32-bit words + * containing + * - 16 4-bit chunky pixels on input + * - permutated planar data (2 planes per 32-bit word) on output + */ + +static void c2p_16x4(CARD32 d[2]) +{ + transp2(d, 8); + transp2(d, 2); + transp2x(d, 1); + transp2(d, 16); + transp2(d, 4); + transp2(d, 1); +} + + + /* + * Store a full block of iplan2p4 data after c2p conversion + */ + +static inline void store_iplan2p4(void *dst, const CARD32 d[2]) +{ + CARD32 *p = dst; + + *p++ = d[0]; + *p++ = d[1]; +} + + +void +shadowUpdateIplan2p4(ScreenPtr pScreen, shadowBufPtr pBuf) +{ + RegionPtr damage = shadowDamage(pBuf); + PixmapPtr pShadow = pBuf->pPixmap; + int nbox = RegionNumRects(damage); + BoxPtr pbox = RegionRects(damage); + FbBits *shaBase; + CARD16 *shaLine, *sha; + FbStride shaStride; + int scrLine; + _X_UNUSED int shaBpp, shaXoff, shaYoff; + int x, y, w, h; + int i, n; + CARD16 *win; + _X_UNUSED CARD32 winSize; + union { + CARD8 bytes[8]; + CARD32 words[2]; + } d; + + fbGetDrawable(&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, + shaYoff); + shaStride *= sizeof(FbBits) / sizeof(CARD16); + + while (nbox--) { + x = pbox->x1; + y = pbox->y1; + w = pbox->x2 - pbox->x1; + h = pbox->y2 - pbox->y1; + + scrLine = (x & -16) / 2; + shaLine = (CARD16 *)shaBase + y * shaStride + scrLine / sizeof(CARD16); + + n = ((x & 15) + w + 15) / 16; /* number of c2p units in scanline */ + + while (h--) { + sha = shaLine; + win = (CARD16 *) (*pBuf->window) (pScreen, + y, + scrLine, + SHADOW_WINDOW_WRITE, + &winSize, + pBuf->closure); + if (!win) + return; + for (i = 0; i < n; i++) { + memcpy(d.bytes, sha, sizeof(d.bytes)); + c2p_16x4(d.words); + store_iplan2p4(win, d.words); + sha += sizeof(d.bytes) / sizeof(*sha); + win += sizeof(d.bytes) / sizeof(*win); + } + shaLine += shaStride; + y++; + } + pbox++; + } +} diff --git a/miext/shadow/shiplan2p8.c b/miext/shadow/shiplan2p8.c new file mode 100644 index 000000000..55762f6d1 --- /dev/null +++ b/miext/shadow/shiplan2p8.c @@ -0,0 +1,137 @@ +/* + * + * Copyright © 2013 Geert Uytterhoeven + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation, and that the name of Geert Uytterhoeven not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Geert Uytterhoeven makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * GEERT UYTTERHOEVEN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL GEERT UYTTERHOEVEN BE LIABLE FOR ANY SPECIAL, INDIRECT OR + * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, + * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER + * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + * PERFORMANCE OF THIS SOFTWARE. + * + * Based on shpacked.c, which is Copyright © 2000 Keith Packard + */ + +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#include + +#include +#include "scrnintstr.h" +#include "windowstr.h" +#include +#include "dixfontstr.h" +#include +#include "mi.h" +#include "regionstr.h" +#include "globals.h" +#include "gcstruct.h" +#include "shadow.h" +#include "fb.h" +#include "c2p_core.h" + + + /* + * Perform a full C2P step on 16 8-bit pixels, stored in 4 32-bit words + * containing + * - 16 8-bit chunky pixels on input + * - permutated planar data (2 planes per 32-bit word) on output + */ + +static void c2p_16x8(CARD32 d[4]) +{ + transp4(d, 8, 2); + transp4(d, 1, 2); + transp4x(d, 16, 2); + transp4x(d, 2, 2); + transp4(d, 4, 1); +} + + + /* + * Store a full block of permutated iplan2p8 data after c2p conversion + */ + +static inline void store_iplan2p8(void *dst, const CARD32 d[4]) +{ + CARD32 *p = dst; + + *p++ = d[1]; + *p++ = d[3]; + *p++ = d[0]; + *p++ = d[2]; +} + + +void +shadowUpdateIplan2p8(ScreenPtr pScreen, shadowBufPtr pBuf) +{ + RegionPtr damage = shadowDamage(pBuf); + PixmapPtr pShadow = pBuf->pPixmap; + int nbox = RegionNumRects(damage); + BoxPtr pbox = RegionRects(damage); + FbBits *shaBase; + CARD16 *shaLine, *sha; + FbStride shaStride; + int scrLine; + _X_UNUSED int shaBpp, shaXoff, shaYoff; + int x, y, w, h; + int i, n; + CARD16 *win; + _X_UNUSED CARD32 winSize; + union { + CARD8 bytes[16]; + CARD32 words[4]; + } d; + + fbGetDrawable(&pShadow->drawable, shaBase, shaStride, shaBpp, shaXoff, + shaYoff); + shaStride *= sizeof(FbBits) / sizeof(CARD16); + + while (nbox--) { + x = pbox->x1; + y = pbox->y1; + w = pbox->x2 - pbox->x1; + h = pbox->y2 - pbox->y1; + + scrLine = x & -16; + shaLine = (CARD16 *)shaBase + y * shaStride + scrLine / sizeof(CARD16); + + n = ((x & 15) + w + 15) / 16; /* number of c2p units in scanline */ + + while (h--) { + sha = shaLine; + win = (CARD16 *) (*pBuf->window) (pScreen, + y, + scrLine, + SHADOW_WINDOW_WRITE, + &winSize, + pBuf->closure); + if (!win) + return; + for (i = 0; i < n; i++) { + memcpy(d.bytes, sha, sizeof(d.bytes)); + c2p_16x8(d.words); + store_iplan2p8(win, d.words); + sha += sizeof(d.bytes) / sizeof(*sha); + win += sizeof(d.bytes) / sizeof(*win); + } + shaLine += shaStride; + y++; + } + pbox++; + } +} diff --git a/miext/shadow/shpacked.c b/miext/shadow/shpacked.c index d2b2e5e24..5ef18f86d 100644 --- a/miext/shadow/shpacked.c +++ b/miext/shadow/shpacked.c @@ -98,7 +98,6 @@ shadowUpdatePacked(ScreenPtr pScreen, shadowBufPtr pBuf) i = width; width -= i; scr += i; -#define PickBit(a,i) (((a) >> (i)) & 1) memcpy(win, sha, i * sizeof(FbBits)); sha += i; } diff --git a/test/input.c b/test/input.c index be988a4a3..df20f8235 100644 --- a/test/input.c +++ b/test/input.c @@ -1384,7 +1384,7 @@ dix_valuator_alloc(void) assert(v); assert(v->numAxes == num_axes); -#if !defined(__i386__) && !defined(__sh__) +#if !defined(__i386__) && !defined(__m68k__) && !defined(__sh__) /* must be double-aligned on 64 bit */ assert(((void *) v->axisVal - (void *) v) % sizeof(double) == 0); assert(((void *) v->axes - (void *) v) % sizeof(double) == 0);