xserver: Branch 'master' - 3 commits
Keith Packard
keithp at kemper.freedesktop.org
Sat Jul 14 09:04:47 PDT 2007
hw/xfree86/common/xf86Config.c | 1
hw/xfree86/modes/xf86Crtc.c | 3
hw/xfree86/modes/xf86Crtc.h | 11 +
hw/xfree86/modes/xf86Cursors.c | 116 +++++++-----
hw/xfree86/modes/xf86Rotate.c | 380 ++++++++++++++++++++++++++++++-----------
randr/rrcrtc.c | 2
6 files changed, 372 insertions(+), 141 deletions(-)
New commits:
diff-tree 393171034c15d8a1b82232b8f9455a358035e932 (from 8773ad023eb28950eb0f802d2ca31a67f84adddc)
Author: Keith Packard <keithp at neko.keithp.com>
Date: Sat Jul 14 09:03:40 2007 -0700
Add RandR reflection support.
Replace the ad-hoc transformation mechanisms with matrices.
Prepares for more general transformation as well.
diff --git a/hw/xfree86/modes/xf86Crtc.c b/hw/xfree86/modes/xf86Crtc.c
index d20a3a3..722b62b 100644
--- a/hw/xfree86/modes/xf86Crtc.c
+++ b/hw/xfree86/modes/xf86Crtc.c
@@ -676,7 +676,8 @@ xf86CrtcScreenInit (ScreenPtr screen)
}
if (c == config->num_crtc)
xf86RandR12SetRotations (screen, RR_Rotate_0 | RR_Rotate_90 |
- RR_Rotate_180 | RR_Rotate_270);
+ RR_Rotate_180 | RR_Rotate_270 |
+ RR_Reflect_X | RR_Reflect_Y);
else
xf86RandR12SetRotations (screen, RR_Rotate_0);
diff --git a/hw/xfree86/modes/xf86Crtc.h b/hw/xfree86/modes/xf86Crtc.h
index 2d62600..982a3d7 100644
--- a/hw/xfree86/modes/xf86Crtc.h
+++ b/hw/xfree86/modes/xf86Crtc.h
@@ -279,6 +279,17 @@ struct _xf86Crtc {
* Track state of cursor associated with this CRTC
*/
Bool cursor_shown;
+
+ /**
+ * Current transformation matrix
+ */
+ PictTransform crtc_to_framebuffer;
+ PictTransform framebuffer_to_crtc;
+ Bool transform_in_use;
+ /**
+ * Bounding box in screen space
+ */
+ BoxRec bounds;
};
typedef struct _xf86OutputFuncs {
diff --git a/hw/xfree86/modes/xf86Cursors.c b/hw/xfree86/modes/xf86Cursors.c
index 009cccf..396bf30 100644
--- a/hw/xfree86/modes/xf86Cursors.c
+++ b/hw/xfree86/modes/xf86Cursors.c
@@ -58,29 +58,73 @@ xf86_crtc_rotate_coord (Rotation rota
int *x_src,
int *y_src)
{
+ int t;
+
+ switch (rotation & 0xf) {
+ case RR_Rotate_0:
+ break;
+ case RR_Rotate_90:
+ t = x_dst;
+ x_dst = height - y_dst - 1;
+ y_dst = t;
+ break;
+ case RR_Rotate_180:
+ x_dst = width - x_dst - 1;
+ y_dst = height - y_dst - 1;
+ break;
+ case RR_Rotate_270:
+ t = x_dst;
+ x_dst = y_dst;
+ y_dst = width - t - 1;
+ break;
+ }
if (rotation & RR_Reflect_X)
x_dst = width - x_dst - 1;
if (rotation & RR_Reflect_Y)
y_dst = height - y_dst - 1;
+ *x_src = x_dst;
+ *y_src = y_dst;
+}
+
+/*
+ * Given a cursor source coordinate, rotate to a screen coordinate
+ */
+static void
+xf86_crtc_rotate_coord_back (Rotation rotation,
+ int width,
+ int height,
+ int x_dst,
+ int y_dst,
+ int *x_src,
+ int *y_src)
+{
+ int t;
+ if (rotation & RR_Reflect_X)
+ x_dst = width - x_dst - 1;
+ if (rotation & RR_Reflect_Y)
+ y_dst = height - y_dst - 1;
+
switch (rotation & 0xf) {
case RR_Rotate_0:
- *x_src = x_dst;
- *y_src = y_dst;
break;
case RR_Rotate_90:
- *x_src = height - y_dst - 1;
- *y_src = x_dst;
+ t = x_dst;
+ x_dst = y_dst;
+ y_dst = width - t - 1;
break;
case RR_Rotate_180:
- *x_src = width - x_dst - 1;
- *y_src = height - y_dst - 1;
+ x_dst = width - x_dst - 1;
+ y_dst = height - y_dst - 1;
break;
case RR_Rotate_270:
- *x_src = y_dst;
- *y_src = width - x_dst - 1;
+ t = x_dst;
+ x_dst = height - y_dst - 1;
+ y_dst = t;
break;
}
+ *x_src = x_dst;
+ *y_src = y_dst;
}
/*
@@ -261,49 +305,33 @@ xf86_crtc_set_cursor_position (xf86CrtcP
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
xf86CursorInfoPtr cursor_info = xf86_config->cursor_info;
DisplayModePtr mode = &crtc->mode;
- int x_temp;
- int y_temp;
Bool in_range;
+ int dx, dy;
- /*
- * Move to crtc coordinate space
- */
- x -= crtc->x;
- y -= crtc->y;
-
/*
- * Rotate
+ * Transform position of cursor on screen
*/
- switch ((crtc->rotation) & 0xf) {
- case RR_Rotate_0:
- break;
- case RR_Rotate_90:
- x_temp = y;
- y_temp = mode->VDisplay - cursor_info->MaxWidth - x;
- x = x_temp;
- y = y_temp;
- break;
- case RR_Rotate_180:
- x_temp = mode->HDisplay - cursor_info->MaxWidth - x;
- y_temp = mode->VDisplay - cursor_info->MaxHeight - y;
- x = x_temp;
- y = y_temp;
- break;
- case RR_Rotate_270:
- x_temp = mode->HDisplay - cursor_info->MaxHeight - y;
- y_temp = x;
- x = x_temp;
- y = y_temp;
- break;
+ if (crtc->transform_in_use)
+ {
+ PictVector v;
+ v.vector[0] = IntToxFixed (x); v.vector[1] = IntToxFixed (y); v.vector[2] = IntToxFixed(1);
+ PictureTransformPoint (&crtc->framebuffer_to_crtc, &v);
+ x = xFixedToInt (v.vector[0]); y = xFixedToInt (v.vector[1]);
+ }
+ else
+ {
+ x -= crtc->x;
+ y -= crtc->y;
}
-
/*
- * Reflect
+ * Transform position of cursor upper left corner
*/
- if (crtc->rotation & RR_Reflect_X)
- x = mode->HDisplay - cursor_info->MaxWidth - x;
- if (crtc->rotation & RR_Reflect_Y)
- y = mode->VDisplay - cursor_info->MaxHeight - y;
+ xf86_crtc_rotate_coord_back (crtc->rotation,
+ cursor_info->MaxWidth,
+ cursor_info->MaxHeight,
+ 0, 0, &dx, &dy);
+ x -= dx;
+ y -= dy;
/*
* Disable the cursor when it is outside the viewport
diff --git a/hw/xfree86/modes/xf86Rotate.c b/hw/xfree86/modes/xf86Rotate.c
index 1379939..4016b97 100644
--- a/hw/xfree86/modes/xf86Rotate.c
+++ b/hw/xfree86/modes/xf86Rotate.c
@@ -68,57 +68,204 @@ compWindowFormat (WindowPtr pWin)
compGetWindowVisual (pWin));
}
+#define F(x) IntToxFixed(x)
+
+static void
+PictureTransformIdentity (PictTransformPtr matrix)
+{
+ int i;
+ memset (matrix, '\0', sizeof (PictTransform));
+ for (i = 0; i < 3; i++)
+ matrix->matrix[i][i] = F(1);
+}
+
+static Bool
+PictureTransformMultiply (PictTransformPtr dst, PictTransformPtr l, PictTransformPtr r)
+{
+ PictTransform d;
+ int dx, dy;
+ int o;
+
+ for (dy = 0; dy < 3; dy++)
+ for (dx = 0; dx < 3; dx++)
+ {
+ xFixed_48_16 v;
+ xFixed_32_32 partial;
+ v = 0;
+ for (o = 0; o < 3; o++)
+ {
+ partial = (xFixed_32_32) l->matrix[dy][o] * (xFixed_32_32) r->matrix[o][dx];
+ v += partial >> 16;
+ }
+ if (v > MAX_FIXED_48_16 || v < MIN_FIXED_48_16)
+ return FALSE;
+ d.matrix[dy][dx] = (xFixed) v;
+ }
+ *dst = d;
+ return TRUE;
+}
+
+static void
+PictureTransformInitScale (PictTransformPtr t, xFixed sx, xFixed sy)
+{
+ memset (t, '\0', sizeof (PictTransform));
+ t->matrix[0][0] = sx;
+ t->matrix[1][1] = sy;
+ t->matrix[2][2] = F (1);
+}
+
+static xFixed
+fixed_inverse (xFixed x)
+{
+ return (xFixed) ((((xFixed_48_16) F(1)) * F(1)) / x);
+}
+
+static Bool
+PictureTransformScale (PictTransformPtr forward,
+ PictTransformPtr reverse,
+ xFixed sx, xFixed sy)
+{
+ PictTransform t;
+
+ PictureTransformInitScale (&t, sx, sy);
+ if (!PictureTransformMultiply (forward, &t, forward))
+ return FALSE;
+ PictureTransformInitScale (&t, fixed_inverse (sx), fixed_inverse (sy));
+ if (!PictureTransformMultiply (reverse, reverse, &t))
+ return FALSE;
+ return TRUE;
+}
+
static void
-xf86TranslateBox (BoxPtr b, int dx, int dy)
+PictureTransformInitRotate (PictTransformPtr t, xFixed c, xFixed s)
{
- b->x1 += dx;
- b->y1 += dy;
- b->x2 += dx;
- b->y2 += dy;
+ memset (t, '\0', sizeof (PictTransform));
+ t->matrix[0][0] = c;
+ t->matrix[0][1] = -s;
+ t->matrix[1][0] = s;
+ t->matrix[1][1] = c;
+ t->matrix[2][2] = F (1);
+}
+
+static Bool
+PictureTransformRotate (PictTransformPtr forward,
+ PictTransformPtr reverse,
+ xFixed c, xFixed s)
+{
+ PictTransform t;
+ PictureTransformInitRotate (&t, c, s);
+ if (!PictureTransformMultiply (forward, &t, forward))
+ return FALSE;
+
+ PictureTransformInitRotate (&t, c, -s);
+ if (!PictureTransformMultiply (reverse, reverse, &t))
+ return FALSE;
+ return TRUE;
}
static void
-xf86TransformBox (BoxPtr dst, BoxPtr src, Rotation rotation,
- int xoff, int yoff,
- int dest_width, int dest_height)
+PictureTransformInitTranslate (PictTransformPtr t, xFixed tx, xFixed ty)
+{
+ memset (t, '\0', sizeof (PictTransform));
+ t->matrix[0][0] = F (1);
+ t->matrix[0][2] = tx;
+ t->matrix[1][1] = F (1);
+ t->matrix[1][2] = ty;
+ t->matrix[2][2] = F (1);
+}
+
+static Bool
+PictureTransformTranslate (PictTransformPtr forward,
+ PictTransformPtr reverse,
+ xFixed tx, xFixed ty)
{
- BoxRec stmp = *src;
+ PictTransform t;
+ PictureTransformInitTranslate (&t, tx, ty);
+ if (!PictureTransformMultiply (forward, &t, forward))
+ return FALSE;
- xf86TranslateBox (&stmp, -xoff, -yoff);
- switch (rotation & 0xf) {
- default:
- case RR_Rotate_0:
- *dst = stmp;
- break;
- case RR_Rotate_90:
- dst->x1 = stmp.y1;
- dst->y1 = dest_height - stmp.x2;
- dst->x2 = stmp.y2;
- dst->y2 = dest_height - stmp.x1;
- break;
- case RR_Rotate_180:
- dst->x1 = dest_width - stmp.x2;
- dst->y1 = dest_height - stmp.y2;
- dst->x2 = dest_width - stmp.x1;
- dst->y2 = dest_height - stmp.y1;
- break;
- case RR_Rotate_270:
- dst->x1 = dest_width - stmp.y2;
- dst->y1 = stmp.x1;
- dst->y2 = stmp.x2;
- dst->x2 = dest_width - stmp.y1;
- break;
- }
- if (rotation & RR_Reflect_X) {
- int x1 = dst->x1;
- dst->x1 = dest_width - dst->x2;
- dst->x2 = dest_width - x1;
- }
- if (rotation & RR_Reflect_Y) {
- int y1 = dst->y1;
- dst->y1 = dest_height - dst->y2;
- dst->y2 = dest_height - y1;
+ PictureTransformInitTranslate (&t, -tx, -ty);
+ if (!PictureTransformMultiply (reverse, reverse, &t))
+ return FALSE;
+ return TRUE;
+}
+
+static void
+PictureTransformBounds (BoxPtr b, PictTransformPtr matrix)
+{
+ PictVector v[4];
+ int i;
+ int x1, y1, x2, y2;
+
+ v[0].vector[0] = F (b->x1); v[0].vector[1] = F (b->y1); v[0].vector[2] = F(1);
+ v[1].vector[0] = F (b->x2); v[1].vector[1] = F (b->y1); v[1].vector[2] = F(1);
+ v[2].vector[0] = F (b->x2); v[2].vector[1] = F (b->y2); v[2].vector[2] = F(1);
+ v[3].vector[0] = F (b->x1); v[3].vector[1] = F (b->y2); v[3].vector[2] = F(1);
+ for (i = 0; i < 4; i++)
+ {
+ PictureTransformPoint (matrix, &v[i]);
+ x1 = xFixedToInt (v[i].vector[0]);
+ y1 = xFixedToInt (v[i].vector[1]);
+ x2 = xFixedToInt (xFixedCeil (v[i].vector[0]));
+ y2 = xFixedToInt (xFixedCeil (v[i].vector[1]));
+ if (i == 0)
+ {
+ b->x1 = x1; b->y1 = y1;
+ b->x2 = x2; b->y2 = y2;
+ }
+ else
+ {
+ if (x1 < b->x1) b->x1 = x1;
+ if (y1 < b->y1) b->y1 = y1;
+ if (x2 > b->x2) b->x2 = x2;
+ if (y2 > b->y2) b->y2 = y2;
+ }
+ }
+}
+
+static Bool
+PictureTransformIsIdentity(PictTransform *t)
+{
+ return ((t->matrix[0][0] == t->matrix[1][1]) &&
+ (t->matrix[0][0] == t->matrix[2][2]) &&
+ (t->matrix[0][0] != 0) &&
+ (t->matrix[0][1] == 0) &&
+ (t->matrix[0][2] == 0) &&
+ (t->matrix[1][0] == 0) &&
+ (t->matrix[1][2] == 0) &&
+ (t->matrix[2][0] == 0) &&
+ (t->matrix[2][1] == 0));
+}
+
+#define toF(x) ((float) (x) / 65536.0f)
+
+static void
+PictureTransformErrorF (PictTransform *t)
+{
+ ErrorF ("{ { %f %f %f } { %f %f %f } { %f %f %f } }",
+ toF(t->matrix[0][0]), toF(t->matrix[0][1]), toF(t->matrix[0][2]),
+ toF(t->matrix[1][0]), toF(t->matrix[1][1]), toF(t->matrix[1][2]),
+ toF(t->matrix[2][0]), toF(t->matrix[2][1]), toF(t->matrix[2][2]));
+}
+
+static Bool
+PictureTransformIsInverse (char *where, PictTransform *a, PictTransform *b)
+{
+ PictTransform t;
+
+ PictureTransformMultiply (&t, a, b);
+ if (!PictureTransformIsIdentity (&t))
+ {
+ ErrorF ("%s: ", where);
+ PictureTransformErrorF (a);
+ ErrorF (" * ");
+ PictureTransformErrorF (b);
+ ErrorF (" = ");
+ PictureTransformErrorF (a);
+ ErrorF ("\n");
+ return FALSE;
}
+ return TRUE;
}
static void
@@ -131,7 +278,6 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crt
PictFormatPtr format = compWindowFormat (WindowTable[screen->myNum]);
int error;
PicturePtr src, dst;
- PictTransform transform;
int n = REGION_NUM_RECTS(region);
BoxPtr b = REGION_RECTS(region);
XID include_inferiors = IncludeInferiors;
@@ -156,45 +302,7 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crt
if (!dst)
return;
- memset (&transform, '\0', sizeof (transform));
- transform.matrix[2][2] = IntToxFixed(1);
- transform.matrix[0][2] = IntToxFixed(crtc->x);
- transform.matrix[1][2] = IntToxFixed(crtc->y);
- switch (crtc->rotation & 0xf) {
- default:
- case RR_Rotate_0:
- transform.matrix[0][0] = IntToxFixed(1);
- transform.matrix[1][1] = IntToxFixed(1);
- break;
- case RR_Rotate_90:
- transform.matrix[0][1] = IntToxFixed(-1);
- transform.matrix[1][0] = IntToxFixed(1);
- transform.matrix[0][2] += IntToxFixed(crtc->mode.VDisplay);
- break;
- case RR_Rotate_180:
- transform.matrix[0][0] = IntToxFixed(-1);
- transform.matrix[1][1] = IntToxFixed(-1);
- transform.matrix[0][2] += IntToxFixed(crtc->mode.HDisplay);
- transform.matrix[1][2] += IntToxFixed(crtc->mode.VDisplay);
- break;
- case RR_Rotate_270:
- transform.matrix[0][1] = IntToxFixed(1);
- transform.matrix[1][0] = IntToxFixed(-1);
- transform.matrix[1][2] += IntToxFixed(crtc->mode.HDisplay);
- break;
- }
-
- /* handle reflection */
- if (crtc->rotation & RR_Reflect_X)
- {
- /* XXX figure this out */
- }
- if (crtc->rotation & RR_Reflect_Y)
- {
- /* XXX figure this out too */
- }
-
- error = SetPictureTransform (src, &transform);
+ error = SetPictureTransform (src, &crtc->crtc_to_framebuffer);
if (error)
return;
@@ -202,9 +310,8 @@ xf86RotateCrtcRedisplay (xf86CrtcPtr crt
{
BoxRec dst_box;
- xf86TransformBox (&dst_box, b, crtc->rotation,
- crtc->x, crtc->y,
- crtc->mode.HDisplay, crtc->mode.VDisplay);
+ dst_box = *b;
+ PictureTransformBounds (&dst_box, &crtc->framebuffer_to_crtc);
CompositePicture (PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1, dst_box.y1,
@@ -296,15 +403,10 @@ xf86RotateRedisplay(ScreenPtr pScreen)
if (crtc->rotation != RR_Rotate_0 && crtc->enabled)
{
- BoxRec box;
RegionRec crtc_damage;
/* compute portion of damage that overlaps crtc */
- box.x1 = crtc->x;
- box.x2 = crtc->x + xf86ModeWidth (&crtc->mode, crtc->rotation);
- box.y1 = crtc->y;
- box.y2 = crtc->y + xf86ModeHeight (&crtc->mode, crtc->rotation);
- REGION_INIT(pScreen, &crtc_damage, &box, 1);
+ REGION_INIT(pScreen, &crtc_damage, &crtc->bounds, 1);
REGION_INTERSECT (pScreen, &crtc_damage, &crtc_damage, region);
/* update damaged region */
@@ -393,13 +495,93 @@ xf86CrtcRotate (xf86CrtcPtr crtc, Displa
ScrnInfoPtr pScrn = crtc->scrn;
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
ScreenPtr pScreen = pScrn->pScreen;
+ PictTransform crtc_to_fb, fb_to_crtc;
+
+ PictureTransformIdentity (&crtc_to_fb);
+ PictureTransformIdentity (&fb_to_crtc);
+ PictureTransformIsInverse ("identity", &crtc_to_fb, &fb_to_crtc);
+ if (rotation != RR_Rotate_0)
+ {
+ xFixed rot_cos, rot_sin, rot_dx, rot_dy;
+ xFixed scale_x, scale_y, scale_dx, scale_dy;
+ int mode_w = crtc->mode.HDisplay;
+ int mode_h = crtc->mode.VDisplay;
+
+ /* rotation */
+ switch (rotation & 0xf) {
+ default:
+ case RR_Rotate_0:
+ rot_cos = F ( 1); rot_sin = F ( 0);
+ rot_dx = F ( 0); rot_dy = F ( 0);
+ break;
+ case RR_Rotate_90:
+ rot_cos = F ( 0); rot_sin = F ( 1);
+ rot_dx = F ( mode_h); rot_dy = F (0);
+ break;
+ case RR_Rotate_180:
+ rot_cos = F (-1); rot_sin = F ( 0);
+ rot_dx = F (mode_w); rot_dy = F ( mode_h);
+ break;
+ case RR_Rotate_270:
+ rot_cos = F ( 0); rot_sin = F (-1);
+ rot_dx = F ( 0); rot_dy = F ( mode_w);
+ break;
+ }
+
+ PictureTransformRotate (&crtc_to_fb, &fb_to_crtc, rot_cos, rot_sin);
+ PictureTransformIsInverse ("rotate", &crtc_to_fb, &fb_to_crtc);
+
+ PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, rot_dx, rot_dy);
+ PictureTransformIsInverse ("rotate translate", &crtc_to_fb, &fb_to_crtc);
+
+ /* reflection */
+ scale_x = F (1);
+ scale_dx = 0;
+ scale_y = F (1);
+ scale_dy = 0;
+ if (rotation & RR_Reflect_X)
+ {
+ scale_x = F(-1);
+ if (rotation & (RR_Rotate_0|RR_Rotate_180))
+ scale_dx = F(mode_w);
+ else
+ scale_dx = F(mode_h);
+ }
+ if (rotation & RR_Reflect_Y)
+ {
+ scale_y = F(-1);
+ if (rotation & (RR_Rotate_0|RR_Rotate_180))
+ scale_dy = F(mode_h);
+ else
+ scale_dy = F(mode_w);
+ }
+
+ PictureTransformScale (&crtc_to_fb, &fb_to_crtc, scale_x, scale_y);
+ PictureTransformIsInverse ("scale", &crtc_to_fb, &fb_to_crtc);
+
+ PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, scale_dx, scale_dy);
+ PictureTransformIsInverse ("scale translate", &crtc_to_fb, &fb_to_crtc);
+
+ }
- if (rotation == RR_Rotate_0)
+ /*
+ * If the untranslated transformation is the identity,
+ * disable the shadow buffer
+ */
+ if (PictureTransformIsIdentity (&crtc_to_fb))
{
+ crtc->transform_in_use = FALSE;
+ PictureTransformInitTranslate (&crtc->crtc_to_framebuffer,
+ F (-crtc->x), F (-crtc->y));
+ PictureTransformInitTranslate (&crtc->framebuffer_to_crtc,
+ F ( crtc->x), F ( crtc->y));
xf86RotateDestroy (crtc);
}
else
{
+ PictureTransformTranslate (&crtc_to_fb, &fb_to_crtc, crtc->x, crtc->y);
+ PictureTransformIsInverse ("offset", &crtc_to_fb, &fb_to_crtc);
+
/*
* these are the size of the shadow pixmap, which
* matches the mode, not the pre-rotated copy in the
@@ -448,14 +630,14 @@ xf86CrtcRotate (xf86CrtcPtr crtc, Displa
}
if (0)
{
-bail2:
+ bail2:
if (shadow || shadowData)
{
crtc->funcs->shadow_destroy (crtc, shadow, shadowData);
crtc->rotatedPixmap = NULL;
crtc->rotatedData = NULL;
}
-bail1:
+ bail1:
if (old_width && old_height)
crtc->rotatedPixmap = crtc->funcs->shadow_create (crtc,
NULL,
@@ -463,6 +645,14 @@ bail1:
old_height);
return FALSE;
}
+ crtc->transform_in_use = TRUE;
+ crtc->crtc_to_framebuffer = crtc_to_fb;
+ crtc->framebuffer_to_crtc = fb_to_crtc;
+ crtc->bounds.x1 = 0;
+ crtc->bounds.x2 = crtc->mode.HDisplay;
+ crtc->bounds.y1 = 0;
+ crtc->bounds.y2 = crtc->mode.VDisplay;
+ PictureTransformBounds (&crtc->bounds, &crtc_to_fb);
}
/* All done */
diff-tree 8773ad023eb28950eb0f802d2ca31a67f84adddc (from 881a620b4d6ea7a54af14c8f8fbe6924c9aa9291)
Author: Keith Packard <keithp at neko.keithp.com>
Date: Sat Jul 14 08:47:50 2007 -0700
Screen size bounds check in ProcRRSetCrtcConfig not masking out reflections.
When checking how to validate the selected mode and position against the
current screen size, the test against 90/270 rotation did not mask out
reflection, so that when reflection was specified, the 90/270 test would
never succeed. This caused incorrect bounds checking and would return
an error to the user instead of rotating the screen.
diff --git a/randr/rrcrtc.c b/randr/rrcrtc.c
index c8c2be2..3ce9e21 100644
--- a/randr/rrcrtc.c
+++ b/randr/rrcrtc.c
@@ -794,7 +794,7 @@ ProcRRSetCrtcConfig (ClientPtr client)
int source_width = mode->mode.width;
int source_height = mode->mode.height;
- if (rotation == RR_Rotate_90 || rotation == RR_Rotate_270)
+ if ((rotation & 0xf) == RR_Rotate_90 || (rotation & 0xf) == RR_Rotate_270)
{
source_width = mode->mode.height;
source_height = mode->mode.width;
diff-tree 881a620b4d6ea7a54af14c8f8fbe6924c9aa9291 (from 031b009ea678809bf1ddca883c2082b304c408c9)
Author: Keith Packard <keithp at neko.keithp.com>
Date: Sat Jul 14 08:45:10 2007 -0700
When sync'ing logfile, also flush it.
When the logfile is set to sync, the actual sync occurs whenever the log
file is flushed. If the log file is not also set to flush, no syncing
occurs.
diff --git a/hw/xfree86/common/xf86Config.c b/hw/xfree86/common/xf86Config.c
index b5b4927..48c178b 100644
--- a/hw/xfree86/common/xf86Config.c
+++ b/hw/xfree86/common/xf86Config.c
@@ -988,6 +988,7 @@ configServerFlags(XF86ConfFlagsPtr flags
} else if (!xf86NameCmp(s,"sync")) {
xf86Msg(X_CONFIG, "Syncing logfile enabled\n");
xf86Info.log = LogSync;
+ LogSetParameter(XLOG_FLUSH, TRUE);
LogSetParameter(XLOG_SYNC, TRUE);
} else {
xf86Msg(X_WARNING,"Unknown Log option\n");
More information about the xorg-commit
mailing list