src/gallium/state_trackers/egl/common/egl_g3d.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.8
   4  *
   5  * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include "egldriver.h"
  27 #include "eglcurrent.h"
  28 #include "egllog.h"
  29
  30 #include "pipe/p_screen.h"
  31 #include "util/u_memory.h"
  32 #include "util/u_format.h"
  33 #include "util/u_string.h"
  34
  35 #include "egl_g3d.h"
  36 #include "egl_g3d_api.h"
  37 #include "egl_g3d_st.h"
  38 #include "egl_g3d_loader.h"
  39 #include "native.h"
  40
  41 /**
  42  * Get the native platform.
  43  */
  44 static const struct native_platform *
  45 egl_g3d_get_platform(_EGLDriver *drv, _EGLPlatformType plat)
  46 {
  47    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
  48
  49    if (!gdrv->platforms[plat]) {
  50       const char *plat_name = NULL;
  51       const struct native_platform *nplat = NULL;
  52
  53       switch (plat) {
  54       case _EGL_PLATFORM_WINDOWS:
  55          plat_name = "Windows";
  56 #ifdef HAVE_GDI_BACKEND
  57          nplat = native_get_gdi_platform();
  58 #endif
  59          break;
  60       case _EGL_PLATFORM_X11:
  61          plat_name = "X11";
  62 #ifdef HAVE_X11_BACKEND
  63          nplat = native_get_x11_platform();
  64 #endif
  65          break;
  66       case _EGL_PLATFORM_DRM:
  67          plat_name = "DRM";
  68 #ifdef HAVE_DRM_BACKEND
  69          nplat = native_get_drm_platform();
  70 #endif
  71          break;
  72       case _EGL_PLATFORM_FBDEV:
  73          plat_name = "FBDEV";
  74 #ifdef HAVE_FBDEV_BACKEND
  75          nplat = native_get_fbdev_platform();
  76 #endif
  77          break;
  78       default:
  79          break;
  80       }
  81
  82       if (!nplat)
  83          _eglLog(_EGL_WARNING, "unsupported platform %s", plat_name);
  84
  85       gdrv->platforms[plat] = nplat;
  86    }
  87
  88    return gdrv->platforms[plat];
  89 }
  90
  91 #ifdef EGL_MESA_screen_surface
  92
  93 static void
  94 egl_g3d_add_screens(_EGLDriver *drv, _EGLDisplay *dpy)
  95 {
  96    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
  97    const struct native_connector **native_connectors;
  98    EGLint num_connectors, i;
  99
 100    native_connectors =
 101       gdpy->native->modeset->get_connectors(gdpy->native, &num_connectors, NULL);
 102    if (!num_connectors) {
 103       if (native_connectors)
 104          FREE(native_connectors);
 105       return;
 106    }
 107
 108    for (i = 0; i < num_connectors; i++) {
 109       const struct native_connector *nconn = native_connectors[i];
 110       struct egl_g3d_screen *gscr;
 111       const struct native_mode **native_modes;
 112       EGLint num_modes, j;
 113
 114       /* TODO support for hotplug */
 115       native_modes =
 116          gdpy->native->modeset->get_modes(gdpy->native, nconn, &num_modes);
 117       if (!num_modes) {
 118          if (native_modes)
 119             FREE(native_modes);
 120          continue;
 121       }
 122
 123       gscr = CALLOC_STRUCT(egl_g3d_screen);
 124       if (!gscr) {
 125          FREE(native_modes);
 126          continue;
 127       }
 128
 129       _eglInitScreen(&gscr->base);
 130
 131       for (j = 0; j < num_modes; j++) {
 132          const struct native_mode *nmode = native_modes[j];
 133          _EGLMode *mode;
 134
 135          mode = _eglAddNewMode(&gscr->base, nmode->width, nmode->height,
 136                nmode->refresh_rate, nmode->desc);
 137          if (!mode)
 138             break;
 139          /* gscr->native_modes and gscr->base.Modes should be consistent */
 140          assert(mode == &gscr->base.Modes[j]);
 141       }
 142
 143       gscr->native = nconn;
 144       gscr->native_modes = native_modes;
 145
 146       _eglAddScreen(dpy, &gscr->base);
 147    }
 148
 149    FREE(native_connectors);
 150 }
 151
 152 #endif /* EGL_MESA_screen_surface */
 153
 154 /**
 155  * Initialize and validate the EGL config attributes.
 156  */
 157 static EGLBoolean
 158 init_config_attributes(_EGLConfig *conf, const struct native_config *nconf,
 159                        EGLint api_mask, enum pipe_format depth_stencil_format)
 160 {
 161    uint rgba[4], depth_stencil[2], buffer_size;
 162    EGLint surface_type;
 163    EGLint i;
 164
 165    /* get the color and depth/stencil component sizes */
 166    assert(nconf->color_format != PIPE_FORMAT_NONE);
 167    buffer_size = 0;
 168    for (i = 0; i < 4; i++) {
 169       rgba[i] = util_format_get_component_bits(nconf->color_format,
 170             UTIL_FORMAT_COLORSPACE_RGB, i);
 171       buffer_size += rgba[i];
 172    }
 173    for (i = 0; i < 2; i++) {
 174       if (depth_stencil_format != PIPE_FORMAT_NONE) {
 175          depth_stencil[i] =
 176             util_format_get_component_bits(depth_stencil_format,
 177                UTIL_FORMAT_COLORSPACE_ZS, i);
 178       }
 179       else {
 180          depth_stencil[i] = 0;
 181       }
 182    }
 183
 184    surface_type = 0x0;
 185    if (nconf->window_bit)
 186       surface_type |= EGL_WINDOW_BIT;
 187    if (nconf->pixmap_bit)
 188       surface_type |= EGL_PIXMAP_BIT;
 189 #ifdef EGL_MESA_screen_surface
 190    if (nconf->scanout_bit)
 191       surface_type |= EGL_SCREEN_BIT_MESA;
 192 #endif
 193
 194    if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
 195       surface_type |= EGL_PBUFFER_BIT;
 196
 197    SET_CONFIG_ATTRIB(conf, EGL_CONFORMANT, api_mask);
 198    SET_CONFIG_ATTRIB(conf, EGL_RENDERABLE_TYPE, api_mask);
 199
 200    SET_CONFIG_ATTRIB(conf, EGL_RED_SIZE, rgba[0]);
 201    SET_CONFIG_ATTRIB(conf, EGL_GREEN_SIZE, rgba[1]);
 202    SET_CONFIG_ATTRIB(conf, EGL_BLUE_SIZE, rgba[2]);
 203    SET_CONFIG_ATTRIB(conf, EGL_ALPHA_SIZE, rgba[3]);
 204    SET_CONFIG_ATTRIB(conf, EGL_BUFFER_SIZE, buffer_size);
 205
 206    SET_CONFIG_ATTRIB(conf, EGL_DEPTH_SIZE, depth_stencil[0]);
 207    SET_CONFIG_ATTRIB(conf, EGL_STENCIL_SIZE, depth_stencil[1]);
 208
 209    SET_CONFIG_ATTRIB(conf, EGL_SURFACE_TYPE, surface_type);
 210
 211    SET_CONFIG_ATTRIB(conf, EGL_NATIVE_RENDERABLE, EGL_TRUE);
 212    if (surface_type & EGL_WINDOW_BIT) {
 213       SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_ID, nconf->native_visual_id);
 214       SET_CONFIG_ATTRIB(conf, EGL_NATIVE_VISUAL_TYPE,
 215             nconf->native_visual_type);
 216    }
 217
 218    if (surface_type & EGL_PBUFFER_BIT) {
 219       SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGB, EGL_TRUE);
 220       if (rgba[3])
 221          SET_CONFIG_ATTRIB(conf, EGL_BIND_TO_TEXTURE_RGBA, EGL_TRUE);
 222
 223       SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_WIDTH, 4096);
 224       SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_HEIGHT, 4096);
 225       SET_CONFIG_ATTRIB(conf, EGL_MAX_PBUFFER_PIXELS, 4096 * 4096);
 226    }
 227
 228    SET_CONFIG_ATTRIB(conf, EGL_LEVEL, nconf->level);
 229    SET_CONFIG_ATTRIB(conf, EGL_SAMPLES, nconf->samples);
 230    SET_CONFIG_ATTRIB(conf, EGL_SAMPLE_BUFFERS, 1);
 231
 232    if (nconf->slow_config)
 233       SET_CONFIG_ATTRIB(conf, EGL_CONFIG_CAVEAT, EGL_SLOW_CONFIG);
 234
 235    if (nconf->transparent_rgb) {
 236       rgba[0] = nconf->transparent_rgb_values[0];
 237       rgba[1] = nconf->transparent_rgb_values[1];
 238       rgba[2] = nconf->transparent_rgb_values[2];
 239
 240       SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_TYPE, EGL_TRANSPARENT_RGB);
 241       SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_RED_VALUE, rgba[0]);
 242       SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_GREEN_VALUE, rgba[1]);
 243       SET_CONFIG_ATTRIB(conf, EGL_TRANSPARENT_BLUE_VALUE, rgba[2]);
 244    }
 245
 246    return _eglValidateConfig(conf, EGL_FALSE);
 247 }
 248
 249 /**
 250  * Initialize an EGL config from the native config.
 251  */
 252 static EGLBoolean
 253 egl_g3d_init_config(_EGLDriver *drv, _EGLDisplay *dpy,
 254                     _EGLConfig *conf, const struct native_config *nconf,
 255                     enum pipe_format depth_stencil_format)
 256 {
 257    struct egl_g3d_config *gconf = egl_g3d_config(conf);
 258    EGLint buffer_mask, api_mask;
 259    EGLBoolean valid;
 260
 261    /* skip single-buffered configs */
 262    if (!(nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT)))
 263       return EGL_FALSE;
 264
 265    buffer_mask = 0x0;
 266    if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_LEFT))
 267       buffer_mask |= ST_ATTACHMENT_FRONT_LEFT_MASK;
 268    if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_LEFT))
 269       buffer_mask |= ST_ATTACHMENT_BACK_LEFT_MASK;
 270    if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_FRONT_RIGHT))
 271       buffer_mask |= ST_ATTACHMENT_FRONT_RIGHT_MASK;
 272    if (nconf->buffer_mask & (1 << NATIVE_ATTACHMENT_BACK_RIGHT))
 273       buffer_mask |= ST_ATTACHMENT_BACK_RIGHT_MASK;
 274
 275    gconf->stvis.buffer_mask = buffer_mask;
 276    gconf->stvis.color_format = nconf->color_format;
 277    gconf->stvis.depth_stencil_format = depth_stencil_format;
 278    gconf->stvis.accum_format = PIPE_FORMAT_NONE;
 279    gconf->stvis.samples = nconf->samples;
 280
 281    gconf->stvis.render_buffer = (buffer_mask & ST_ATTACHMENT_BACK_LEFT_MASK) ?
 282       ST_ATTACHMENT_BACK_LEFT : ST_ATTACHMENT_FRONT_LEFT;
 283
 284    api_mask = dpy->ClientAPIsMask;
 285    /* this is required by EGL, not by OpenGL ES */
 286    if (nconf->window_bit &&
 287        gconf->stvis.render_buffer != ST_ATTACHMENT_BACK_LEFT)
 288       api_mask &= ~(EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT);
 289
 290    if (!api_mask) {
 291       _eglLog(_EGL_DEBUG, "no state tracker supports config 0x%x",
 292             nconf->native_visual_id);
 293    }
 294
 295    valid = init_config_attributes(&gconf->base,
 296          nconf, api_mask, depth_stencil_format);
 297    if (!valid) {
 298       _eglLog(_EGL_DEBUG, "skip invalid config 0x%x", nconf->native_visual_id);
 299       return EGL_FALSE;
 300    }
 301
 302    gconf->native = nconf;
 303
 304    return EGL_TRUE;
 305 }
 306
 307 /**
 308  * Get all interested depth/stencil formats of a display.
 309  */
 310 static EGLint
 311 egl_g3d_fill_depth_stencil_formats(_EGLDisplay *dpy,
 312                                    enum pipe_format formats[8])
 313 {
 314    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 315    struct pipe_screen *screen = gdpy->native->screen;
 316    const EGLint candidates[] = {
 317       1, PIPE_FORMAT_Z16_UNORM,
 318       1, PIPE_FORMAT_Z32_UNORM,
 319       2, PIPE_FORMAT_Z24_UNORM_S8_USCALED, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 320       2, PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
 321       0
 322    };
 323    const EGLint *fmt = candidates;
 324    EGLint count;
 325
 326    count = 0;
 327    formats[count++] = PIPE_FORMAT_NONE;
 328
 329    while (*fmt) {
 330       EGLint i, n = *fmt++;
 331
 332       /* pick the first supported format */
 333       for (i = 0; i < n; i++) {
 334          if (screen->is_format_supported(screen, fmt[i],
 335                   PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0)) {
 336             formats[count++] = fmt[i];
 337             break;
 338          }
 339       }
 340
 341       fmt += n;
 342    }
 343
 344    return count;
 345 }
 346
 347 /**
 348  * Add configs to display and return the next config ID.
 349  */
 350 static EGLint
 351 egl_g3d_add_configs(_EGLDriver *drv, _EGLDisplay *dpy, EGLint id)
 352 {
 353    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 354    const struct native_config **native_configs;
 355    enum pipe_format depth_stencil_formats[8];
 356    int num_formats, num_configs, i, j;
 357
 358    native_configs = gdpy->native->get_configs(gdpy->native, &num_configs);
 359    if (!num_configs) {
 360       if (native_configs)
 361          FREE(native_configs);
 362       return id;
 363    }
 364
 365    num_formats = egl_g3d_fill_depth_stencil_formats(dpy,
 366          depth_stencil_formats);
 367
 368    for (i = 0; i < num_configs; i++) {
 369       for (j = 0; j < num_formats; j++) {
 370          struct egl_g3d_config *gconf;
 371
 372          gconf = CALLOC_STRUCT(egl_g3d_config);
 373          if (gconf) {
 374             _eglInitConfig(&gconf->base, dpy, id);
 375             if (!egl_g3d_init_config(drv, dpy, &gconf->base,
 376                      native_configs[i], depth_stencil_formats[j])) {
 377                FREE(gconf);
 378                break;
 379             }
 380
 381             _eglAddConfig(dpy, &gconf->base);
 382             id++;
 383          }
 384       }
 385    }
 386
 387    FREE(native_configs);
 388    return id;
 389 }
 390
 391 static void
 392 egl_g3d_invalid_surface(struct native_display *ndpy,
 393                         struct native_surface *nsurf,
 394                         unsigned int seq_num)
 395 {
 396    /* XXX not thread safe? */
 397    struct egl_g3d_surface *gsurf = egl_g3d_surface(nsurf->user_data);
 398    struct egl_g3d_context *gctx;
 399
 400    /*
 401     * Some functions such as egl_g3d_copy_buffers create a temporary native
 402     * surface.  There is no gsurf associated with it.
 403     */
 404    gctx = (gsurf) ? egl_g3d_context(gsurf->base.CurrentContext) : NULL;
 405    if (gctx)
 406       gctx->stctxi->notify_invalid_framebuffer(gctx->stctxi, gsurf->stfbi);
 407 }
 408
 409 static struct pipe_screen *
 410 egl_g3d_new_drm_screen(struct native_display *ndpy, const char *name, int fd)
 411 {
 412    _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data;
 413    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 414    return gdpy->loader->create_drm_screen(name, fd);
 415 }
 416
 417 static struct pipe_screen *
 418 egl_g3d_new_sw_screen(struct native_display *ndpy, struct sw_winsys *ws)
 419 {
 420    _EGLDisplay *dpy = (_EGLDisplay *) ndpy->user_data;
 421    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 422    return gdpy->loader->create_sw_screen(ws);
 423 }
 424
 425 static struct native_event_handler egl_g3d_native_event_handler = {
 426    egl_g3d_invalid_surface,
 427    egl_g3d_new_drm_screen,
 428    egl_g3d_new_sw_screen
 429 };
 430
 431 static void
 432 egl_g3d_free_config(void *conf)
 433 {
 434    struct egl_g3d_config *gconf = egl_g3d_config((_EGLConfig *) conf);
 435    FREE(gconf);
 436 }
 437
 438 static void
 439 egl_g3d_free_screen(void *scr)
 440 {
 441 #ifdef EGL_MESA_screen_surface
 442    struct egl_g3d_screen *gscr = egl_g3d_screen((_EGLScreen *) scr);
 443    FREE(gscr->native_modes);
 444    FREE(gscr);
 445 #endif
 446 }
 447
 448 static EGLBoolean
 449 egl_g3d_terminate(_EGLDriver *drv, _EGLDisplay *dpy)
 450 {
 451    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 452
 453    _eglReleaseDisplayResources(drv, dpy);
 454
 455    if (gdpy->pipe)
 456       gdpy->pipe->destroy(gdpy->pipe);
 457
 458    if (dpy->Configs) {
 459       _eglDestroyArray(dpy->Configs, egl_g3d_free_config);
 460       dpy->Configs = NULL;
 461    }
 462    if (dpy->Screens) {
 463       _eglDestroyArray(dpy->Screens, egl_g3d_free_screen);
 464       dpy->Screens = NULL;
 465    }
 466
 467    _eglCleanupDisplay(dpy);
 468
 469    if (gdpy->smapi)
 470       egl_g3d_destroy_st_manager(gdpy->smapi);
 471
 472    if (gdpy->native)
 473       gdpy->native->destroy(gdpy->native);
 474
 475    FREE(gdpy);
 476    dpy->DriverData = NULL;
 477
 478    return EGL_TRUE;
 479 }
 480
 481 static EGLBoolean
 482 egl_g3d_initialize(_EGLDriver *drv, _EGLDisplay *dpy,
 483                    EGLint *major, EGLint *minor)
 484 {
 485    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
 486    struct egl_g3d_display *gdpy;
 487    const struct native_platform *nplat;
 488
 489    nplat = egl_g3d_get_platform(drv, dpy->Platform);
 490    if (!nplat)
 491       return EGL_FALSE;
 492
 493    gdpy = CALLOC_STRUCT(egl_g3d_display);
 494    if (!gdpy) {
 495       _eglError(EGL_BAD_ALLOC, "eglInitialize");
 496       goto fail;
 497    }
 498    gdpy->loader = gdrv->loader;
 499    dpy->DriverData = gdpy;
 500
 501    _eglLog(_EGL_INFO, "use %s for display %p", nplat->name, dpy->PlatformDisplay);
 502    gdpy->native = nplat->create_display(dpy->PlatformDisplay,
 503          &egl_g3d_native_event_handler, (void *) dpy);
 504    if (!gdpy->native) {
 505       _eglError(EGL_NOT_INITIALIZED, "eglInitialize(no usable display)");
 506       goto fail;
 507    }
 508
 509    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_DEFAULT_MASK)
 510       dpy->ClientAPIsMask |= EGL_OPENGL_BIT;
 511    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES1_MASK)
 512       dpy->ClientAPIsMask |= EGL_OPENGL_ES_BIT;
 513    if (gdpy->loader->profile_masks[ST_API_OPENGL] & ST_PROFILE_OPENGL_ES2_MASK)
 514       dpy->ClientAPIsMask |= EGL_OPENGL_ES2_BIT;
 515    if (gdpy->loader->profile_masks[ST_API_OPENVG] & ST_PROFILE_DEFAULT_MASK)
 516       dpy->ClientAPIsMask |= EGL_OPENVG_BIT;
 517
 518    gdpy->smapi = egl_g3d_create_st_manager(dpy);
 519    if (!gdpy->smapi) {
 520       _eglError(EGL_NOT_INITIALIZED,
 521             "eglInitialize(failed to create st manager)");
 522       goto fail;
 523    }
 524
 525 #ifdef EGL_MESA_screen_surface
 526    /* enable MESA_screen_surface before adding (and validating) configs */
 527    if (gdpy->native->modeset) {
 528       dpy->Extensions.MESA_screen_surface = EGL_TRUE;
 529       egl_g3d_add_screens(drv, dpy);
 530    }
 531 #endif
 532
 533    dpy->Extensions.KHR_image_base = EGL_TRUE;
 534    if (gdpy->native->get_param(gdpy->native, NATIVE_PARAM_USE_NATIVE_BUFFER))
 535       dpy->Extensions.KHR_image_pixmap = EGL_TRUE;
 536
 537    dpy->Extensions.KHR_reusable_sync = EGL_TRUE;
 538    dpy->Extensions.KHR_fence_sync = EGL_TRUE;
 539
 540    dpy->Extensions.KHR_surfaceless_gles1 = EGL_TRUE;
 541    dpy->Extensions.KHR_surfaceless_gles2 = EGL_TRUE;
 542    dpy->Extensions.KHR_surfaceless_opengl = EGL_TRUE;
 543
 544    if (dpy->Platform == _EGL_PLATFORM_DRM) {
 545       dpy->Extensions.MESA_drm_display = EGL_TRUE;
 546       dpy->Extensions.MESA_drm_image = EGL_TRUE;
 547    }
 548
 549    if (egl_g3d_add_configs(drv, dpy, 1) == 1) {
 550       _eglError(EGL_NOT_INITIALIZED, "eglInitialize(unable to add configs)");
 551       goto fail;
 552    }
 553
 554    *major = 1;
 555    *minor = 4;
 556
 557    return EGL_TRUE;
 558
 559 fail:
 560    if (gdpy)
 561       egl_g3d_terminate(drv, dpy);
 562    return EGL_FALSE;
 563 }
 564
 565 static _EGLProc
 566 egl_g3d_get_proc_address(_EGLDriver *drv, const char *procname)
 567 {
 568    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
 569    struct st_api *stapi = NULL;
 570
 571    if (procname && procname[0] == 'v' && procname[1] == 'g')
 572       stapi = gdrv->loader->get_st_api(ST_API_OPENVG);
 573    else if (procname && procname[0] == 'g' && procname[1] == 'l')
 574       stapi = gdrv->loader->get_st_api(ST_API_OPENGL);
 575
 576    return (_EGLProc) ((stapi) ?
 577          stapi->get_proc_address(stapi, procname) : NULL);
 578 }
 579
 580 static EGLint
 581 egl_g3d_probe(_EGLDriver *drv, _EGLDisplay *dpy)
 582 {
 583    return (egl_g3d_get_platform(drv, dpy->Platform)) ? 90 : 0;
 584 }
 585
 586 _EGLDriver *
 587 egl_g3d_create_driver(const struct egl_g3d_loader *loader)
 588 {
 589    struct egl_g3d_driver *gdrv;
 590
 591    gdrv = CALLOC_STRUCT(egl_g3d_driver);
 592    if (!gdrv)
 593       return NULL;
 594
 595    gdrv->loader = loader;
 596
 597    egl_g3d_init_driver_api(&gdrv->base);
 598    gdrv->base.API.Initialize = egl_g3d_initialize;
 599    gdrv->base.API.Terminate = egl_g3d_terminate;
 600    gdrv->base.API.GetProcAddress = egl_g3d_get_proc_address;
 601
 602    gdrv->base.Probe = egl_g3d_probe;
 603
 604    /* to be filled by the caller */
 605    gdrv->base.Name = NULL;
 606    gdrv->base.Unload = NULL;
 607
 608    return &gdrv->base;
 609 }
 610
 611 void
 612 egl_g3d_destroy_driver(_EGLDriver *drv)
 613 {
 614    struct egl_g3d_driver *gdrv = egl_g3d_driver(drv);
 615    FREE(gdrv);
 616 }