1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/*
* Mesa 3-D graphics library
* Version: 6.3
*
* Copyright (C) 1999-2004 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include "glxheader.h"
#include "main/context.h"
#include "main/macros.h"
#include "main/imports.h"
#include "main/mtypes.h"
#include "xmesaP.h"
#include "swrast/swrast.h"
/*
* The following functions are used to trap XGetImage() calls which
* generate BadMatch errors if the drawable isn't mapped.
*/
static int caught_xgetimage_error = 0;
static int (*old_xerror_handler)( XMesaDisplay *dpy, XErrorEvent *ev );
static unsigned long xgetimage_serial;
/*
* This is the error handler which will be called if XGetImage fails.
*/
static int xgetimage_error_handler( XMesaDisplay *dpy, XErrorEvent *ev )
{
if (ev->serial==xgetimage_serial && ev->error_code==BadMatch) {
/* caught the expected error */
caught_xgetimage_error = 0;
}
else {
/* call the original X error handler, if any. otherwise ignore */
if (old_xerror_handler) {
(*old_xerror_handler)( dpy, ev );
}
}
return 0;
}
/*
* Call this right before XGetImage to setup error trap.
*/
static void catch_xgetimage_errors( XMesaDisplay *dpy )
{
xgetimage_serial = NextRequest( dpy );
old_xerror_handler = XSetErrorHandler( xgetimage_error_handler );
caught_xgetimage_error = 0;
}
/*
* Call this right after XGetImage to check if an error occured.
*/
static int check_xgetimage_errors( void )
{
/* restore old handler */
(void) XSetErrorHandler( old_xerror_handler );
/* return 0=no error, 1=error caught */
return caught_xgetimage_error;
}
/*
* Read a pixel from an X drawable.
*/
static unsigned long read_pixel( XMesaDisplay *dpy,
XMesaDrawable d, int x, int y )
{
unsigned long p;
XMesaImage *pixel = NULL;
int error;
catch_xgetimage_errors( dpy );
pixel = XGetImage( dpy, d, x, y, 1, 1, AllPlanes, ZPixmap );
error = check_xgetimage_errors();
if (pixel && !error) {
p = XMesaGetPixel( pixel, 0, 0 );
}
else {
p = 0;
}
if (pixel) {
XMesaDestroyImage( pixel );
}
return p;
}
/*
* The Mesa library needs to be able to draw pixels in a number of ways:
* 1. RGB vs Color Index
* 2. as horizontal spans (polygons, images) vs random locations (points,
* lines)
* 3. different color per-pixel or same color for all pixels
*
* Furthermore, the X driver needs to support rendering to 3 possible
* "buffers", usually one, but sometimes two at a time:
* 1. The front buffer as an X window
* 2. The back buffer as a Pixmap
* 3. The back buffer as an XImage
*
* Finally, if the back buffer is an XImage, we can avoid using XPutPixel and
* optimize common cases such as 24-bit and 8-bit modes.
*
* By multiplication, there's at least 48 possible combinations of the above.
*
* Below are implementations of the most commonly used combinations. They are
* accessed through function pointers which get initialized here and are used
* directly from the Mesa library. The 8 function pointers directly correspond
* to the first 3 cases listed above.
*
*
* The function naming convention is:
*
* [put|get]_[row|values]_[format]_[pixmap|ximage]
*
* New functions optimized for specific cases can be added without too much
* trouble. An example might be the 24-bit TrueColor mode 8A8R8G8B which is
* found on IBM RS/6000 X servers.
*/
/**********************************************************************/
/***** Pixel reading *****/
/**********************************************************************/
/**
* Do clip testing prior to calling XGetImage. If any of the region lies
* outside the screen's bounds, XGetImage will return NULL.
* We use XTranslateCoordinates() to check if that's the case and
* adjust the x, y and length parameters accordingly.
* \return -1 if span is totally clipped away,
* else return number of pixels to skip in the destination array.
*/
static int
clip_for_xgetimage(struct gl_context *ctx, XMesaPixmap pixmap, GLuint *n, GLint *x, GLint *y)
{
XMesaContext xmesa = XMESA_CONTEXT(ctx);
XMesaBuffer source = XMESA_BUFFER(ctx->DrawBuffer);
Window rootWin = RootWindow(xmesa->display, 0);
Window child;
GLint screenWidth = WidthOfScreen(DefaultScreenOfDisplay(xmesa->display));
GLint dx, dy;
if (source->type == PBUFFER || source->type == PIXMAP)
return 0;
XTranslateCoordinates(xmesa->display, pixmap, rootWin,
*x, *y, &dx, &dy, &child);
if (dx >= screenWidth) {
/* totally clipped on right */
return -1;
}
if (dx < 0) {
/* clipped on left */
GLint clip = -dx;
if (clip >= (GLint) *n)
return -1; /* totally clipped on left */
*x += clip;
*n -= clip;
dx = 0;
return clip;
}
if ((GLint) (dx + *n) > screenWidth) {
/* clipped on right */
GLint clip = dx + *n - screenWidth;
*n -= clip;
}
return 0;
}
#define GET_XRB(XRB) \
struct xmesa_renderbuffer *XRB = xmesa_renderbuffer(rb)
/**
* Initialize the renderbuffer's PutRow, GetRow, etc. functions.
* This would generally only need to be called once when the renderbuffer
* is created. However, we can change pixel formats on the fly if dithering
* is enabled/disabled. Therefore, we may call this more often than that.
*/
void
xmesa_set_renderbuffer_funcs(struct xmesa_renderbuffer *xrb,
enum pixel_format pixelformat, GLint depth)
{
/* XXX remove this */
}
|
