Remove Xcalloc/Xmalloc/Xfree calls
[mesa.git] / src / gallium / state_trackers / egl / x11 / glxinit.c
1 /**
2 * GLX initialization. Code based on glxext.c, glx_query.c, and
3 * glcontextmodes.c under src/glx/. The major difference is that DRI
4 * related code is stripped out.
5 *
6 * If the maintenance of this file takes too much time, we should consider
7 * refactoring glxext.c.
8 */
9
10 #include <assert.h>
11 #include <X11/Xlib.h>
12 #include <X11/Xproto.h>
13 #include <X11/Xlibint.h>
14 #include <X11/extensions/Xext.h>
15 #include <X11/extensions/extutil.h>
16 #include <sys/time.h>
17
18 #include "GL/glxproto.h"
19 #include "GL/glxtokens.h"
20 #include "GL/gl.h" /* for GL types needed by __GLcontextModes */
21 #include "glcore.h" /* for __GLcontextModes */
22
23 #include "glxinit.h"
24
25 #ifdef GLX_DIRECT_RENDERING
26
27 typedef struct GLXGenericGetString
28 {
29 CARD8 reqType;
30 CARD8 glxCode;
31 CARD16 length B16;
32 CARD32 for_whom B32;
33 CARD32 name B32;
34 } xGLXGenericGetStringReq;
35
36 #define sz_xGLXGenericGetStringReq 12
37 #define X_GLXGenericGetString 0
38
39 /* Extension required boiler plate */
40
41 static char *__glXExtensionName = GLX_EXTENSION_NAME;
42 static XExtensionInfo *__glXExtensionInfo = NULL;
43
44 static int
45 __glXCloseDisplay(Display * dpy, XExtCodes * codes)
46 {
47 return XextRemoveDisplay(__glXExtensionInfo, dpy);
48 }
49
50 static /* const */ XExtensionHooks __glXExtensionHooks = {
51 NULL, /* create_gc */
52 NULL, /* copy_gc */
53 NULL, /* flush_gc */
54 NULL, /* free_gc */
55 NULL, /* create_font */
56 NULL, /* free_font */
57 __glXCloseDisplay, /* close_display */
58 NULL, /* wire_to_event */
59 NULL, /* event_to_wire */
60 NULL, /* error */
61 NULL, /* error_string */
62 };
63
64 static XEXT_GENERATE_FIND_DISPLAY(__glXFindDisplay, __glXExtensionInfo,
65 __glXExtensionName, &__glXExtensionHooks,
66 __GLX_NUMBER_EVENTS, NULL)
67
68 static GLint
69 _gl_convert_from_x_visual_type(int visualType)
70 {
71 #define NUM_VISUAL_TYPES 6
72 static const int glx_visual_types[NUM_VISUAL_TYPES] = {
73 GLX_STATIC_GRAY, GLX_GRAY_SCALE,
74 GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
75 GLX_TRUE_COLOR, GLX_DIRECT_COLOR
76 };
77
78 return ((unsigned) visualType < NUM_VISUAL_TYPES)
79 ? glx_visual_types[visualType] : GLX_NONE;
80 }
81
82 static void
83 _gl_context_modes_destroy(__GLcontextModes * modes)
84 {
85 while (modes != NULL) {
86 __GLcontextModes *const next = modes->next;
87
88 free(modes);
89 modes = next;
90 }
91 }
92
93 static __GLcontextModes *
94 _gl_context_modes_create(unsigned count, size_t minimum_size)
95 {
96 const size_t size = (minimum_size > sizeof(__GLcontextModes))
97 ? minimum_size : sizeof(__GLcontextModes);
98 __GLcontextModes *base = NULL;
99 __GLcontextModes **next;
100 unsigned i;
101
102 next = &base;
103 for (i = 0; i < count; i++) {
104 *next = (__GLcontextModes *) malloc(size);
105 if (*next == NULL) {
106 _gl_context_modes_destroy(base);
107 base = NULL;
108 break;
109 }
110
111 memset(*next, 0, size);
112 (*next)->visualID = GLX_DONT_CARE;
113 (*next)->visualType = GLX_DONT_CARE;
114 (*next)->visualRating = GLX_NONE;
115 (*next)->transparentPixel = GLX_NONE;
116 (*next)->transparentRed = GLX_DONT_CARE;
117 (*next)->transparentGreen = GLX_DONT_CARE;
118 (*next)->transparentBlue = GLX_DONT_CARE;
119 (*next)->transparentAlpha = GLX_DONT_CARE;
120 (*next)->transparentIndex = GLX_DONT_CARE;
121 (*next)->xRenderable = GLX_DONT_CARE;
122 (*next)->fbconfigID = GLX_DONT_CARE;
123 (*next)->swapMethod = GLX_SWAP_UNDEFINED_OML;
124 (*next)->bindToTextureRgb = GLX_DONT_CARE;
125 (*next)->bindToTextureRgba = GLX_DONT_CARE;
126 (*next)->bindToMipmapTexture = GLX_DONT_CARE;
127 (*next)->bindToTextureTargets = GLX_DONT_CARE;
128 (*next)->yInverted = GLX_DONT_CARE;
129
130 next = &((*next)->next);
131 }
132
133 return base;
134 }
135
136 static char *
137 __glXQueryServerString(Display * dpy, int opcode, CARD32 screen, CARD32 name)
138 {
139 xGLXGenericGetStringReq *req;
140 xGLXSingleReply reply;
141 int length;
142 int numbytes;
143 char *buf;
144 CARD32 for_whom = screen;
145 CARD32 glxCode = X_GLXQueryServerString;
146
147
148 LockDisplay(dpy);
149
150
151 /* All of the GLX protocol requests for getting a string from the server
152 * look the same. The exact meaning of the for_whom field is usually
153 * either the screen number (for glXQueryServerString) or the context tag
154 * (for GLXSingle).
155 */
156
157 GetReq(GLXGenericGetString, req);
158 req->reqType = opcode;
159 req->glxCode = glxCode;
160 req->for_whom = for_whom;
161 req->name = name;
162
163 _XReply(dpy, (xReply *) & reply, 0, False);
164
165 length = reply.length * 4;
166 numbytes = reply.size;
167
168 buf = (char *) malloc(numbytes);
169 if (buf != NULL) {
170 _XRead(dpy, buf, numbytes);
171 length -= numbytes;
172 }
173
174 _XEatData(dpy, length);
175
176 UnlockDisplay(dpy);
177 SyncHandle();
178
179 return buf;
180 }
181
182 /************************************************************************/
183 /*
184 ** Free the per screen configs data as well as the array of
185 ** __glXScreenConfigs.
186 */
187 static void
188 FreeScreenConfigs(__GLXdisplayPrivate * priv)
189 {
190 __GLXscreenConfigs *psc;
191 GLint i, screens;
192
193 /* Free screen configuration information */
194 screens = ScreenCount(priv->dpy);
195 for (i = 0; i < screens; i++) {
196 psc = priv->screenConfigs[i];
197 if (!psc)
198 continue;
199 if (psc->configs) {
200 _gl_context_modes_destroy(psc->configs);
201 psc->configs = NULL; /* NOTE: just for paranoia */
202 }
203 free((char *) psc->serverGLXexts);
204 }
205 free((char *) priv->screenConfigs);
206 priv->screenConfigs = NULL;
207 }
208
209 /*
210 ** Release the private memory referred to in a display private
211 ** structure. The caller will free the extension structure.
212 */
213 static int
214 __glXFreeDisplayPrivate(XExtData * extension)
215 {
216 __GLXdisplayPrivate *priv;
217
218 priv = (__GLXdisplayPrivate *) extension->private_data;
219 FreeScreenConfigs(priv);
220 if (priv->serverGLXversion)
221 free((char *) priv->serverGLXversion);
222
223 free((char *) priv);
224 return 0;
225 }
226
227 /************************************************************************/
228
229 /*
230 ** Query the version of the GLX extension. This procedure works even if
231 ** the client extension is not completely set up.
232 */
233
234 #define GLX_MAJOR_VERSION 1 /* current version numbers */
235 #define GLX_MINOR_VERSION 4
236
237 static Bool
238 QueryVersion(Display * dpy, int opcode, int *major, int *minor)
239 {
240 xGLXQueryVersionReq *req;
241 xGLXQueryVersionReply reply;
242
243 /* Send the glXQueryVersion request */
244 LockDisplay(dpy);
245 GetReq(GLXQueryVersion, req);
246 req->reqType = opcode;
247 req->glxCode = X_GLXQueryVersion;
248 req->majorVersion = GLX_MAJOR_VERSION;
249 req->minorVersion = GLX_MINOR_VERSION;
250 _XReply(dpy, (xReply *) & reply, 0, False);
251 UnlockDisplay(dpy);
252 SyncHandle();
253
254 if (reply.majorVersion != GLX_MAJOR_VERSION) {
255 /*
256 ** The server does not support the same major release as this
257 ** client.
258 */
259 return GL_FALSE;
260 }
261 *major = reply.majorVersion;
262 *minor = min(reply.minorVersion, GLX_MINOR_VERSION);
263 return GL_TRUE;
264 }
265
266 #define __GLX_MIN_CONFIG_PROPS 18
267 #define __GLX_MAX_CONFIG_PROPS 500
268 #define __GLX_EXT_CONFIG_PROPS 10
269 #define __GLX_TOTAL_CONFIG (__GLX_MIN_CONFIG_PROPS + \
270 2 * __GLX_EXT_CONFIG_PROPS)
271
272 static void
273 __glXInitializeVisualConfigFromTags(__GLcontextModes * config, int count,
274 const INT32 * bp, Bool tagged_only,
275 Bool fbconfig_style_tags)
276 {
277 int i;
278
279 if (!tagged_only) {
280 /* Copy in the first set of properties */
281 config->visualID = *bp++;
282
283 config->visualType = _gl_convert_from_x_visual_type(*bp++);
284
285 config->rgbMode = *bp++;
286
287 config->redBits = *bp++;
288 config->greenBits = *bp++;
289 config->blueBits = *bp++;
290 config->alphaBits = *bp++;
291 config->accumRedBits = *bp++;
292 config->accumGreenBits = *bp++;
293 config->accumBlueBits = *bp++;
294 config->accumAlphaBits = *bp++;
295
296 config->doubleBufferMode = *bp++;
297 config->stereoMode = *bp++;
298
299 config->rgbBits = *bp++;
300 config->depthBits = *bp++;
301 config->stencilBits = *bp++;
302 config->numAuxBuffers = *bp++;
303 config->level = *bp++;
304
305 count -= __GLX_MIN_CONFIG_PROPS;
306 }
307
308 /*
309 ** Additional properties may be in a list at the end
310 ** of the reply. They are in pairs of property type
311 ** and property value.
312 */
313
314 #define FETCH_OR_SET(tag) \
315 config-> tag = ( fbconfig_style_tags ) ? *bp++ : 1
316
317 for (i = 0; i < count; i += 2) {
318 switch (*bp++) {
319 case GLX_RGBA:
320 FETCH_OR_SET(rgbMode);
321 break;
322 case GLX_BUFFER_SIZE:
323 config->rgbBits = *bp++;
324 break;
325 case GLX_LEVEL:
326 config->level = *bp++;
327 break;
328 case GLX_DOUBLEBUFFER:
329 FETCH_OR_SET(doubleBufferMode);
330 break;
331 case GLX_STEREO:
332 FETCH_OR_SET(stereoMode);
333 break;
334 case GLX_AUX_BUFFERS:
335 config->numAuxBuffers = *bp++;
336 break;
337 case GLX_RED_SIZE:
338 config->redBits = *bp++;
339 break;
340 case GLX_GREEN_SIZE:
341 config->greenBits = *bp++;
342 break;
343 case GLX_BLUE_SIZE:
344 config->blueBits = *bp++;
345 break;
346 case GLX_ALPHA_SIZE:
347 config->alphaBits = *bp++;
348 break;
349 case GLX_DEPTH_SIZE:
350 config->depthBits = *bp++;
351 break;
352 case GLX_STENCIL_SIZE:
353 config->stencilBits = *bp++;
354 break;
355 case GLX_ACCUM_RED_SIZE:
356 config->accumRedBits = *bp++;
357 break;
358 case GLX_ACCUM_GREEN_SIZE:
359 config->accumGreenBits = *bp++;
360 break;
361 case GLX_ACCUM_BLUE_SIZE:
362 config->accumBlueBits = *bp++;
363 break;
364 case GLX_ACCUM_ALPHA_SIZE:
365 config->accumAlphaBits = *bp++;
366 break;
367 case GLX_VISUAL_CAVEAT_EXT:
368 config->visualRating = *bp++;
369 break;
370 case GLX_X_VISUAL_TYPE:
371 config->visualType = *bp++;
372 break;
373 case GLX_TRANSPARENT_TYPE:
374 config->transparentPixel = *bp++;
375 break;
376 case GLX_TRANSPARENT_INDEX_VALUE:
377 config->transparentIndex = *bp++;
378 break;
379 case GLX_TRANSPARENT_RED_VALUE:
380 config->transparentRed = *bp++;
381 break;
382 case GLX_TRANSPARENT_GREEN_VALUE:
383 config->transparentGreen = *bp++;
384 break;
385 case GLX_TRANSPARENT_BLUE_VALUE:
386 config->transparentBlue = *bp++;
387 break;
388 case GLX_TRANSPARENT_ALPHA_VALUE:
389 config->transparentAlpha = *bp++;
390 break;
391 case GLX_VISUAL_ID:
392 config->visualID = *bp++;
393 break;
394 case GLX_DRAWABLE_TYPE:
395 config->drawableType = *bp++;
396 break;
397 case GLX_RENDER_TYPE:
398 config->renderType = *bp++;
399 break;
400 case GLX_X_RENDERABLE:
401 config->xRenderable = *bp++;
402 break;
403 case GLX_FBCONFIG_ID:
404 config->fbconfigID = *bp++;
405 break;
406 case GLX_MAX_PBUFFER_WIDTH:
407 config->maxPbufferWidth = *bp++;
408 break;
409 case GLX_MAX_PBUFFER_HEIGHT:
410 config->maxPbufferHeight = *bp++;
411 break;
412 case GLX_MAX_PBUFFER_PIXELS:
413 config->maxPbufferPixels = *bp++;
414 break;
415 case GLX_OPTIMAL_PBUFFER_WIDTH_SGIX:
416 config->optimalPbufferWidth = *bp++;
417 break;
418 case GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX:
419 config->optimalPbufferHeight = *bp++;
420 break;
421 case GLX_VISUAL_SELECT_GROUP_SGIX:
422 config->visualSelectGroup = *bp++;
423 break;
424 case GLX_SWAP_METHOD_OML:
425 config->swapMethod = *bp++;
426 break;
427 case GLX_SAMPLE_BUFFERS_SGIS:
428 config->sampleBuffers = *bp++;
429 break;
430 case GLX_SAMPLES_SGIS:
431 config->samples = *bp++;
432 break;
433 case GLX_BIND_TO_TEXTURE_RGB_EXT:
434 config->bindToTextureRgb = *bp++;
435 break;
436 case GLX_BIND_TO_TEXTURE_RGBA_EXT:
437 config->bindToTextureRgba = *bp++;
438 break;
439 case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
440 config->bindToMipmapTexture = *bp++;
441 break;
442 case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
443 config->bindToTextureTargets = *bp++;
444 break;
445 case GLX_Y_INVERTED_EXT:
446 config->yInverted = *bp++;
447 break;
448 case None:
449 i = count;
450 break;
451 default:
452 break;
453 }
454 }
455
456 config->renderType =
457 (config->rgbMode) ? GLX_RGBA_BIT : GLX_COLOR_INDEX_BIT;
458
459 config->haveAccumBuffer = ((config->accumRedBits +
460 config->accumGreenBits +
461 config->accumBlueBits +
462 config->accumAlphaBits) > 0);
463 config->haveDepthBuffer = (config->depthBits > 0);
464 config->haveStencilBuffer = (config->stencilBits > 0);
465 }
466
467 static __GLcontextModes *
468 createConfigsFromProperties(Display * dpy, int nvisuals, int nprops,
469 int screen, GLboolean tagged_only)
470 {
471 INT32 buf[__GLX_TOTAL_CONFIG], *props;
472 unsigned prop_size;
473 __GLcontextModes *modes, *m;
474 int i;
475
476 if (nprops == 0)
477 return NULL;
478
479 /* FIXME: Is the __GLX_MIN_CONFIG_PROPS test correct for FBconfigs? */
480
481 /* Check number of properties */
482 if (nprops < __GLX_MIN_CONFIG_PROPS || nprops > __GLX_MAX_CONFIG_PROPS)
483 return NULL;
484
485 /* Allocate memory for our config structure */
486 modes = _gl_context_modes_create(nvisuals, sizeof(__GLcontextModes));
487 if (!modes)
488 return NULL;
489
490 prop_size = nprops * __GLX_SIZE_INT32;
491 if (prop_size <= sizeof(buf))
492 props = buf;
493 else
494 props = malloc(prop_size);
495
496 /* Read each config structure and convert it into our format */
497 m = modes;
498 for (i = 0; i < nvisuals; i++) {
499 _XRead(dpy, (char *) props, prop_size);
500 /* Older X servers don't send this so we default it here. */
501 m->drawableType = GLX_WINDOW_BIT;
502 __glXInitializeVisualConfigFromTags(m, nprops, props,
503 tagged_only, GL_TRUE);
504 m->screen = screen;
505 m = m->next;
506 }
507
508 if (props != buf)
509 free(props);
510
511 return modes;
512 }
513
514 static GLboolean
515 getFBConfigs(__GLXscreenConfigs *psc, __GLXdisplayPrivate *priv, int screen)
516 {
517 xGLXGetFBConfigsReq *fb_req;
518 xGLXGetFBConfigsSGIXReq *sgi_req;
519 xGLXVendorPrivateWithReplyReq *vpreq;
520 xGLXGetFBConfigsReply reply;
521 Display *dpy = priv->dpy;
522
523 psc->serverGLXexts =
524 __glXQueryServerString(dpy, priv->majorOpcode, screen, GLX_EXTENSIONS);
525
526 LockDisplay(dpy);
527
528 psc->configs = NULL;
529 if (atof(priv->serverGLXversion) >= 1.3) {
530 GetReq(GLXGetFBConfigs, fb_req);
531 fb_req->reqType = priv->majorOpcode;
532 fb_req->glxCode = X_GLXGetFBConfigs;
533 fb_req->screen = screen;
534 }
535 else if (strstr(psc->serverGLXexts, "GLX_SGIX_fbconfig") != NULL) {
536 GetReqExtra(GLXVendorPrivateWithReply,
537 sz_xGLXGetFBConfigsSGIXReq +
538 sz_xGLXVendorPrivateWithReplyReq, vpreq);
539 sgi_req = (xGLXGetFBConfigsSGIXReq *) vpreq;
540 sgi_req->reqType = priv->majorOpcode;
541 sgi_req->glxCode = X_GLXVendorPrivateWithReply;
542 sgi_req->vendorCode = X_GLXvop_GetFBConfigsSGIX;
543 sgi_req->screen = screen;
544 }
545 else
546 goto out;
547
548 if (!_XReply(dpy, (xReply *) & reply, 0, False))
549 goto out;
550
551 psc->configs = createConfigsFromProperties(dpy,
552 reply.numFBConfigs,
553 reply.numAttribs * 2,
554 screen, GL_TRUE);
555
556 out:
557 UnlockDisplay(dpy);
558 return psc->configs != NULL;
559 }
560
561 static GLboolean
562 AllocAndFetchScreenConfigs(Display * dpy, __GLXdisplayPrivate * priv)
563 {
564 __GLXscreenConfigs *psc;
565 GLint i, screens;
566
567 /*
568 ** First allocate memory for the array of per screen configs.
569 */
570 screens = ScreenCount(dpy);
571 priv->screenConfigs = malloc(screens * sizeof *priv->screenConfigs);
572 if (!priv->screenConfigs) {
573 return GL_FALSE;
574 }
575
576 priv->serverGLXversion =
577 __glXQueryServerString(dpy, priv->majorOpcode, 0, GLX_VERSION);
578 if (priv->serverGLXversion == NULL) {
579 FreeScreenConfigs(priv);
580 return GL_FALSE;
581 }
582
583 for (i = 0; i < screens; i++) {
584 psc = calloc(1, sizeof *psc);
585 if (!psc)
586 return GL_FALSE;
587 getFBConfigs(psc, priv, i);
588 priv->screenConfigs[i] = psc;
589 }
590
591 SyncHandle();
592
593 return GL_TRUE;
594 }
595
596 _X_HIDDEN __GLXdisplayPrivate *
597 __glXInitialize(Display * dpy)
598 {
599 XExtDisplayInfo *info = __glXFindDisplay(dpy);
600 XExtData **privList, *private, *found;
601 __GLXdisplayPrivate *dpyPriv;
602 XEDataObject dataObj;
603 int major, minor;
604
605 if (!XextHasExtension(info))
606 return NULL;
607
608 /* See if a display private already exists. If so, return it */
609 dataObj.display = dpy;
610 privList = XEHeadOfExtensionList(dataObj);
611 found = XFindOnExtensionList(privList, info->codes->extension);
612 if (found)
613 return (__GLXdisplayPrivate *) found->private_data;
614
615 /* See if the versions are compatible */
616 if (!QueryVersion(dpy, info->codes->major_opcode, &major, &minor))
617 return NULL;
618
619 /*
620 ** Allocate memory for all the pieces needed for this buffer.
621 */
622 private = (XExtData *) malloc(sizeof(XExtData));
623 if (!private)
624 return NULL;
625 dpyPriv = (__GLXdisplayPrivate *) calloc(1, sizeof(__GLXdisplayPrivate));
626 if (!dpyPriv) {
627 free(private);
628 return NULL;
629 }
630
631 /*
632 ** Init the display private and then read in the screen config
633 ** structures from the server.
634 */
635 dpyPriv->majorOpcode = info->codes->major_opcode;
636 dpyPriv->dpy = dpy;
637
638 if (!AllocAndFetchScreenConfigs(dpy, dpyPriv)) {
639 free(dpyPriv);
640 free(private);
641 return NULL;
642 }
643
644 /*
645 ** Fill in the private structure. This is the actual structure that
646 ** hangs off of the Display structure. Our private structure is
647 ** referred to by this structure. Got that?
648 */
649 private->number = info->codes->extension;
650 private->next = 0;
651 private->free_private = __glXFreeDisplayPrivate;
652 private->private_data = (char *) dpyPriv;
653 XAddToExtensionList(privList, private);
654
655 return dpyPriv;
656 }
657
658 #endif /* GLX_DIRECT_RENDERING */