andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'geertu/master'

Browse Source
This commit is contained in:
Keith Packard 2013-04-24 14:14:45 -07:00
commit 7ab98bafc9
12 changed files with 891 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
hw/kdrive/fbdev/fbdev.c
View File

@ -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;

2
hw/kdrive/fbdev/fbdev.h
View File

@ -49,7 +49,7 @@ typedef struct _fbdevScrPriv {
} FbdevScrPriv;
extern KdCardFuncs fbdevFuncs;
extern char *fbdevDevicePath;
extern const char *fbdevDevicePath;
Bool
fbdevCardInit(KdCardInfo * card);

3
hw/kdrive/src/kdrive.c
View File

@ -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;

4
miext/shadow/Makefile.am
View File

@ -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 \

184
miext/shadow/c2p_core.h Normal file
View File

@ -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;
}

12
miext/shadow/shadow.h
View File

@ -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);

139
miext/shadow/shafb4.c Normal file
View File

@ -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 <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/fonts/font.h>
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#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++;
}
}

143
miext/shadow/shafb8.c Normal file
View File

@ -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 <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/fonts/font.h>
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#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++;
}
}

136
miext/shadow/shiplan2p4.c Normal file
View File

@ -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 <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/fonts/font.h>
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#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++;
}
}

137
miext/shadow/shiplan2p8.c Normal file
View File

@ -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 <dix-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#include <X11/fonts/font.h>
#include "dixfontstr.h"
#include <X11/fonts/fontstruct.h>
#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++;
}
}

1
miext/shadow/shpacked.c
View File

@ -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;
}

2
test/input.c
View File

@ -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);