/[gentoo-x86]/x11-base/xorg-server/files/04-mesa-copy-sub-buffer.patch
Gentoo

Contents of /x11-base/xorg-server/files/04-mesa-copy-sub-buffer.patch

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.2 - (show annotations) (download)
Sun Sep 9 10:34:45 2007 UTC (6 years, 11 months ago) by dberkholz
Branch: MAIN
CVS Tags: HEAD
Changes since 1.1: +0 -0 lines
FILE REMOVED
Drop 1.1, everyone's stable on 1.2 or 1.3.
(Portage version: 2.1.3.8)

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

  ViewVC Help
Powered by ViewVC 1.1.20