Contents of /trunk/xorg-server/patches/xorg-server-1.1.1-aiglx-mesa-copy-sub-buffer.patch
Parent Directory | Revision Log
Revision 153 -
(show annotations)
(download)
Tue May 8 20:52:56 2007 UTC (17 years, 4 months ago) by niro
File size: 11609 byte(s)
Tue May 8 20:52:56 2007 UTC (17 years, 4 months ago) by niro
File size: 11609 byte(s)
-import
1 | --- ./GL/glx/glxdrawable.h.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400 |
2 | +++ ./GL/glx/glxdrawable.h 2006-07-06 21:56:33.000000000 -0400 |
3 | @@ -58,6 +58,8 @@ |
4 | void (*destroy)(__GLXdrawable *private); |
5 | GLboolean (*resize)(__GLXdrawable *private); |
6 | GLboolean (*swapBuffers)(__GLXdrawable *); |
7 | + void (*copySubBuffer)(__GLXdrawable *drawable, |
8 | + int x, int y, int w, int h); |
9 | |
10 | /* |
11 | ** list of drawable private structs |
12 | --- ./GL/glx/glxcmds.c.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400 |
13 | +++ ./GL/glx/glxcmds.c 2006-07-06 22:30:01.000000000 -0400 |
14 | @@ -1331,21 +1331,14 @@ |
15 | |
16 | /*****************************************************************************/ |
17 | |
18 | -/* |
19 | -** NOTE: There is no portable implementation for swap buffers as of |
20 | -** this time that is of value. Consequently, this code must be |
21 | -** implemented by somebody other than SGI. |
22 | -*/ |
23 | -int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc) |
24 | +static __GLXdrawable * |
25 | +SyncContextGetDrawable (__GLXclientState *cl, GLXContextTag tag, |
26 | + XID drawId, int *status) |
27 | { |
28 | ClientPtr client = cl->client; |
29 | DrawablePtr pDraw; |
30 | - xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc; |
31 | - GLXContextTag tag = req->contextTag; |
32 | - XID drawId = req->drawable; |
33 | __GLXpixmap *pGlxPixmap; |
34 | __GLXcontext *glxc = NULL; |
35 | - int error; |
36 | |
37 | /* |
38 | ** Check that the GLX drawable is valid. |
39 | @@ -1361,11 +1354,11 @@ |
40 | ** Drawable is an X pixmap, which is not allowed. |
41 | */ |
42 | client->errorValue = drawId; |
43 | - return __glXBadDrawable; |
44 | + *status = __glXBadDrawable; |
45 | + return NULL; |
46 | } |
47 | } else { |
48 | - pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId, |
49 | - __glXPixmapRes); |
50 | + pGlxPixmap = (__GLXpixmap *) LookupIDByType(drawId, __glXPixmapRes); |
51 | if (pGlxPixmap) { |
52 | /* |
53 | ** Drawable is a GLX pixmap. |
54 | @@ -1375,21 +1368,23 @@ |
55 | ** Drawable is neither a X window nor a GLX pixmap. |
56 | */ |
57 | client->errorValue = drawId; |
58 | - return __glXBadDrawable; |
59 | + *status = __glXBadDrawable; |
60 | + return NULL; |
61 | } |
62 | } |
63 | |
64 | if (tag) { |
65 | glxc = __glXLookupContextByTag(cl, tag); |
66 | if (!glxc) { |
67 | - return __glXBadContextTag; |
68 | + *status = __glXBadContextTag; |
69 | + return NULL; |
70 | } |
71 | /* |
72 | ** The calling thread is swapping its current drawable. In this case, |
73 | ** glxSwapBuffers is in both GL and X streams, in terms of |
74 | ** sequentiality. |
75 | */ |
76 | - if (__glXForceCurrent(cl, tag, &error)) { |
77 | + if (__glXForceCurrent(cl, tag, status)) { |
78 | /* |
79 | ** Do whatever is needed to make sure that all preceding requests |
80 | ** in both streams are completed before the swap is executed. |
81 | @@ -1397,33 +1392,53 @@ |
82 | CALL_Finish( GET_DISPATCH(), () ); |
83 | __GLX_NOTE_FLUSHED_CMDS(glxc); |
84 | } else { |
85 | - return error; |
86 | + return NULL; |
87 | } |
88 | } |
89 | |
90 | + *status = Success; |
91 | if (pDraw) { |
92 | - __GLXdrawable *glxPriv; |
93 | + __GLXdrawable *glxPriv; |
94 | |
95 | if (glxc) { |
96 | glxPriv = __glXGetDrawable(glxc, pDraw, drawId); |
97 | if (glxPriv == NULL) { |
98 | - return __glXBadDrawable; |
99 | + *status = __glXBadDrawable; |
100 | + return NULL; |
101 | } |
102 | } |
103 | else { |
104 | glxPriv = __glXFindDrawable(drawId); |
105 | if (glxPriv == NULL) { |
106 | /* This is a window we've never seen before, do nothing */ |
107 | - return Success; |
108 | + return NULL; |
109 | } |
110 | } |
111 | |
112 | - if ((*glxPriv->swapBuffers)(glxPriv) == GL_FALSE) { |
113 | - return __glXBadDrawable; |
114 | - } |
115 | + return glxPriv; |
116 | } |
117 | |
118 | - return Success; |
119 | + return NULL; |
120 | +} |
121 | + |
122 | +/* |
123 | +** NOTE: There is no portable implementation for swap buffers as of |
124 | +** this time that is of value. Consequently, this code must be |
125 | +** implemented by somebody other than SGI. |
126 | +*/ |
127 | +int __glXSwapBuffers(__GLXclientState *cl, GLbyte *pc) |
128 | +{ |
129 | + xGLXSwapBuffersReq *req = (xGLXSwapBuffersReq *) pc; |
130 | + GLXContextTag tag = req->contextTag; |
131 | + __GLXdrawable *glxPriv; |
132 | + int status; |
133 | + |
134 | + glxPriv = SyncContextGetDrawable (cl, tag, req->drawable, &status); |
135 | + if (glxPriv && (*glxPriv->swapBuffers)(glxPriv) == GL_FALSE) { |
136 | + return __glXBadDrawable; |
137 | + } |
138 | + |
139 | + return status; |
140 | } |
141 | |
142 | |
143 | @@ -1544,6 +1559,30 @@ |
144 | pGlxPixmap); |
145 | } |
146 | |
147 | +int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc) |
148 | +{ |
149 | + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; |
150 | + GLXContextTag tag = req->contextTag; |
151 | + __GLXdrawable *glxPriv; |
152 | + GLXDrawable drawId; |
153 | + int x, y, width, height; |
154 | + int status; |
155 | + |
156 | + pc += __GLX_VENDPRIV_HDR_SIZE; |
157 | + |
158 | + drawId = *((CARD32 *) (pc)); |
159 | + x = *((INT32 *) (pc + 4)); |
160 | + y = *((INT32 *) (pc + 8)); |
161 | + width = *((INT32 *) (pc + 12)); |
162 | + height = *((INT32 *) (pc + 16)); |
163 | + |
164 | + glxPriv = SyncContextGetDrawable (cl, tag, drawId, &status); |
165 | + if (glxPriv) |
166 | + (*glxPriv->copySubBuffer)(glxPriv, x, y, width, height); |
167 | + |
168 | + return status; |
169 | +} |
170 | + |
171 | /* |
172 | ** Get drawable attributes |
173 | */ |
174 | @@ -2173,7 +2212,9 @@ |
175 | case X_GLXvop_BindTexImageEXT: |
176 | return __glXBindTexImageEXT(cl, pc); |
177 | case X_GLXvop_ReleaseTexImageEXT: |
178 | - return __glXReleaseTexImageEXT(cl, pc); |
179 | + return __glXReleaseTexImageEXT(cl, pc); |
180 | + case X_GLXvop_CopySubBufferMESA: |
181 | + return __glXCopySubBufferMESA(cl, pc); |
182 | } |
183 | #endif |
184 | |
185 | --- ./GL/glx/glxdri.c.mesa-copy-sub-buffer 2006-07-06 21:40:41.000000000 -0400 |
186 | +++ ./GL/glx/glxdri.c 2006-07-06 21:59:38.000000000 -0400 |
187 | @@ -112,12 +112,28 @@ |
188 | * months ago. :( |
189 | * 20050727 - Gut all the old interfaces. This breaks compatability with |
190 | * any DRI driver built to any previous version. |
191 | + * 20060314 - Added support for GLX_MESA_copy_sub_buffer. |
192 | */ |
193 | + |
194 | #define INTERNAL_VERSION 20050727 |
195 | |
196 | static const char CREATE_NEW_SCREEN_FUNC[] = |
197 | "__driCreateNewScreen_" STRINGIFY (INTERNAL_VERSION); |
198 | |
199 | +/* The DRI driver entry point version wasn't bumped when the |
200 | + * copySubBuffer functionality was added to the DRI drivers, but the |
201 | + * functionality is still conditional on the value of the |
202 | + * internal_api_version passed to __driCreateNewScreen. However, the |
203 | + * screen constructor doesn't fail for a DRI driver that's older than |
204 | + * the passed in version number, so there's no way we can know for |
205 | + * sure that we can actually use the copySubBuffer functionality. But |
206 | + * since the earliest (and at this point only) released mesa version |
207 | + * (6.5) that uses the 20050727 entry point does have copySubBuffer, |
208 | + * we'll just settle for that. We still have to pass in a higher to |
209 | + * the screen constructor to enable the functionality. |
210 | + */ |
211 | +#define COPY_SUB_BUFFER_INTERNAL_VERSION 20060314 |
212 | + |
213 | static void |
214 | __glXDRIleaveServer(void) |
215 | { |
216 | @@ -177,6 +193,27 @@ |
217 | return TRUE; |
218 | } |
219 | |
220 | +static void |
221 | +__glXDRIdrawableCopySubBuffer(__GLXdrawable *basePrivate, |
222 | + int x, int y, int w, int h) |
223 | +{ |
224 | + __GLXDRIdrawable *private = (__GLXDRIdrawable *) basePrivate; |
225 | + __GLXDRIscreen *screen; |
226 | + |
227 | + /* FIXME: We're jumping through hoops here to get the DRIdrawable |
228 | + * which the dri driver tries to keep to it self... cf. FIXME in |
229 | + * createDrawable. */ |
230 | + |
231 | + screen = (__GLXDRIscreen *) __glXgetActiveScreen(private->base.pDraw->pScreen->myNum); |
232 | + private->driDrawable = (screen->driScreen.getDrawable)(NULL, |
233 | + private->base.drawId, |
234 | + screen->driScreen.private); |
235 | + |
236 | + (*private->driDrawable->copySubBuffer)(NULL, |
237 | + private->driDrawable->private, |
238 | + x, y, w, h); |
239 | +} |
240 | + |
241 | static __GLXdrawable * |
242 | __glXDRIcontextCreateDrawable(__GLXcontext *context, |
243 | DrawablePtr pDraw, |
244 | @@ -195,10 +232,11 @@ |
245 | return NULL; |
246 | } |
247 | |
248 | - private->base.destroy = __glXDRIdrawableDestroy; |
249 | - private->base.resize = __glXDRIdrawableResize; |
250 | - private->base.swapBuffers = __glXDRIdrawableSwapBuffers; |
251 | - |
252 | + private->base.destroy = __glXDRIdrawableDestroy; |
253 | + private->base.resize = __glXDRIdrawableResize; |
254 | + private->base.swapBuffers = __glXDRIdrawableSwapBuffers; |
255 | + private->base.copySubBuffer = __glXDRIdrawableCopySubBuffer; |
256 | + |
257 | #if 0 |
258 | /* FIXME: It would only be natural that we called |
259 | * driScreen->createNewDrawable here but the DRI drivers manage |
260 | @@ -218,7 +256,6 @@ |
261 | return &private->base; |
262 | } |
263 | |
264 | - |
265 | static void |
266 | __glXDRIcontextDestroy(__GLXcontext *baseContext) |
267 | { |
268 | @@ -770,7 +807,7 @@ |
269 | __DRIframebuffer framebuffer; |
270 | int fd = -1; |
271 | int status; |
272 | - int api_ver = INTERNAL_VERSION; |
273 | + int api_ver = COPY_SUB_BUFFER_INTERNAL_VERSION; |
274 | drm_magic_t magic; |
275 | drmVersionPtr version; |
276 | char *driverName; |
277 | --- ./GL/glx/g_disptab.h.mesa-copy-sub-buffer 2006-03-11 19:11:33.000000000 -0500 |
278 | +++ ./GL/glx/g_disptab.h 2006-07-06 21:56:33.000000000 -0400 |
279 | @@ -48,6 +48,7 @@ |
280 | extern int __glXSwapBuffers(__GLXclientState*, GLbyte*); |
281 | extern int __glXBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); |
282 | extern int __glXReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); |
283 | +extern int __glXCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc); |
284 | extern int __glXGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); |
285 | extern int __glXUseXFont(__GLXclientState*, GLbyte*); |
286 | extern int __glXCreateGLXPixmap(__GLXclientState*, GLbyte*); |
287 | @@ -76,6 +77,7 @@ |
288 | extern int __glXSwapSwapBuffers(__GLXclientState*, GLbyte*); |
289 | extern int __glXSwapBindTexImageEXT(__GLXclientState *cl, GLbyte *pc); |
290 | extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); |
291 | +extern int __glXSwapReleaseTexImageEXT(__GLXclientState *cl, GLbyte *pc); |
292 | extern int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc); |
293 | extern int __glXSwapUseXFont(__GLXclientState*, GLbyte*); |
294 | extern int __glXSwapCreateGLXPixmap(__GLXclientState*, GLbyte*); |
295 | @@ -105,4 +107,11 @@ |
296 | extern __GLXdispatchSingleProcPtr __glXSingleTable[__GLX_SINGLE_TABLE_SIZE]; |
297 | extern __GLXdispatchRenderProcPtr __glXSwapRenderTable[__GLX_RENDER_TABLE_SIZE]; |
298 | extern __GLXdispatchSingleProcPtr __glXSwapSingleTable[__GLX_SINGLE_TABLE_SIZE]; |
299 | + |
300 | +/* Copied from mesa src/glx/x11/glxcmds.c |
301 | + * |
302 | + * Apparently there's no standardized opcode for this extension. |
303 | + */ |
304 | +#define X_GLXvop_CopySubBufferMESA 5154 /* temporary */ |
305 | + |
306 | #endif /* _GLX_g_disptab_h_ */ |
307 | --- ./GL/glx/glxscreens.c.mesa-copy-sub-buffer 2006-03-20 15:10:29.000000000 -0500 |
308 | +++ ./GL/glx/glxscreens.c 2006-07-06 21:56:33.000000000 -0400 |
309 | @@ -139,6 +139,7 @@ |
310 | "GLX_SGIX_swap_barrier " |
311 | #endif |
312 | "GLX_SGIX_fbconfig " |
313 | + "GLX_MESA_copy_sub_buffer " |
314 | ; |
315 | |
316 | __GLXscreen **__glXActiveScreens; |
317 | --- ./GL/glx/glxcmdsswap.c.mesa-copy-sub-buffer 2006-04-02 22:09:15.000000000 -0400 |
318 | +++ ./GL/glx/glxcmdsswap.c 2006-07-06 21:56:33.000000000 -0400 |
319 | @@ -432,6 +432,31 @@ |
320 | return __glXReleaseTexImageEXT(cl, (GLbyte *)pc); |
321 | } |
322 | |
323 | +int __glXSwapCopySubBufferMESA(__GLXclientState *cl, GLbyte *pc) |
324 | +{ |
325 | + xGLXVendorPrivateReq *req = (xGLXVendorPrivateReq *) pc; |
326 | + GLXDrawable *drawId; |
327 | + int *buffer; |
328 | + |
329 | + (void) drawId; |
330 | + (void) buffer; |
331 | + |
332 | + __GLX_DECLARE_SWAP_VARIABLES; |
333 | + |
334 | + pc += __GLX_VENDPRIV_HDR_SIZE; |
335 | + |
336 | + __GLX_SWAP_SHORT(&req->length); |
337 | + __GLX_SWAP_INT(&req->contextTag); |
338 | + __GLX_SWAP_INT(pc); |
339 | + __GLX_SWAP_INT(pc + 4); |
340 | + __GLX_SWAP_INT(pc + 8); |
341 | + __GLX_SWAP_INT(pc + 12); |
342 | + __GLX_SWAP_INT(pc + 16); |
343 | + |
344 | + return __glXCopySubBufferMESA(cl, pc); |
345 | + |
346 | +} |
347 | + |
348 | int __glXSwapGetDrawableAttributesSGIX(__GLXclientState *cl, GLbyte *pc) |
349 | { |
350 | xGLXVendorPrivateWithReplyReq *req = (xGLXVendorPrivateWithReplyReq *)pc; |
351 | @@ -899,7 +924,9 @@ |
352 | case X_GLXvop_BindTexImageEXT: |
353 | return __glXSwapBindTexImageEXT(cl, pc); |
354 | case X_GLXvop_ReleaseTexImageEXT: |
355 | - return __glXSwapReleaseTexImageEXT(cl, pc); |
356 | + return __glXSwapReleaseTexImageEXT(cl, pc); |
357 | + case X_GLXvop_CopySubBufferMESA: |
358 | + return __glXSwapCopySubBufferMESA(cl, pc); |
359 | } |
360 | #endif |
361 |