src/egl/main/eglcontext.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright 2009-2010 Chia-I Wu <olvaffe@gmail.com>
   5  * Copyright 2010-2011 LunarG, Inc.
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial portions
  18  * of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26  * DEALINGS IN THE SOFTWARE.
  27  *
  28  **************************************************************************/
  29
  30
  31 #include <assert.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include "eglconfig.h"
  35 #include "eglcontext.h"
  36 #include "egldisplay.h"
  37 #include "eglcurrent.h"
  38 #include "eglsurface.h"
  39 #include "egllog.h"
  40
  41
  42 /**
  43  * Return the API bit (one of EGL_xxx_BIT) of the context.
  44  */
  45 static EGLint
  46 _eglGetContextAPIBit(_EGLContext *ctx)
  47 {
  48    EGLint bit = 0;
  49
  50    switch (ctx->ClientAPI) {
  51    case EGL_OPENGL_ES_API:
  52       switch (ctx->ClientVersion) {
  53       case 1:
  54          bit = EGL_OPENGL_ES_BIT;
  55          break;
  56       case 2:
  57          bit = EGL_OPENGL_ES2_BIT;
  58          break;
  59       default:
  60          break;
  61       }
  62       break;
  63    case EGL_OPENVG_API:
  64       bit = EGL_OPENVG_BIT;
  65       break;
  66    case EGL_OPENGL_API:
  67       bit = EGL_OPENGL_BIT;
  68       break;
  69    default:
  70       break;
  71    }
  72
  73    return bit;
  74 }
  75
  76
  77 /**
  78  * Parse the list of context attributes and return the proper error code.
  79  */
  80 static EGLint
  81 _eglParseContextAttribList(_EGLContext *ctx, const EGLint *attrib_list)
  82 {
  83    EGLenum api = ctx->ClientAPI;
  84    EGLint i, err = EGL_SUCCESS;
  85
  86    if (!attrib_list)
  87       return EGL_SUCCESS;
  88
  89    for (i = 0; attrib_list[i] != EGL_NONE; i++) {
  90       EGLint attr = attrib_list[i++];
  91       EGLint val = attrib_list[i];
  92
  93       switch (attr) {
  94       case EGL_CONTEXT_CLIENT_VERSION:
  95          if (api != EGL_OPENGL_ES_API) {
  96             err = EGL_BAD_ATTRIBUTE;
  97             break;
  98          }
  99          if (val != 1 && val != 2) {
 100             err = EGL_BAD_ATTRIBUTE;
 101             break;
 102          }
 103          ctx->ClientVersion = val;
 104          break;
 105       default:
 106          err = EGL_BAD_ATTRIBUTE;
 107          break;
 108       }
 109
 110       if (err != EGL_SUCCESS) {
 111          _eglLog(_EGL_DEBUG, "bad context attribute 0x%04x", attr);
 112          break;
 113       }
 114    }
 115
 116    return err;
 117 }
 118
 119
 120 /**
 121  * Initialize the given _EGLContext object to defaults and/or the values
 122  * in the attrib_list.
 123  */
 124 EGLBoolean
 125 _eglInitContext(_EGLContext *ctx, _EGLDisplay *dpy, _EGLConfig *conf,
 126                 const EGLint *attrib_list)
 127 {
 128    const EGLenum api = eglQueryAPI();
 129    EGLint err;
 130
 131    if (api == EGL_NONE) {
 132       _eglError(EGL_BAD_MATCH, "eglCreateContext(no client API)");
 133       return EGL_FALSE;
 134    }
 135
 136    _eglInitResource(&ctx->Resource, sizeof(*ctx), dpy);
 137    ctx->ClientAPI = api;
 138    ctx->Config = conf;
 139    ctx->WindowRenderBuffer = EGL_NONE;
 140
 141    ctx->ClientVersion = 1; /* the default, per EGL spec */
 142
 143    err = _eglParseContextAttribList(ctx, attrib_list);
 144    if (err == EGL_SUCCESS && ctx->Config) {
 145       EGLint api_bit;
 146
 147       api_bit = _eglGetContextAPIBit(ctx);
 148       if (!(ctx->Config->RenderableType & api_bit)) {
 149          _eglLog(_EGL_DEBUG, "context api is 0x%x while config supports 0x%x",
 150                api_bit, ctx->Config->RenderableType);
 151          err = EGL_BAD_CONFIG;
 152       }
 153    }
 154    if (err != EGL_SUCCESS)
 155       return _eglError(err, "eglCreateContext");
 156
 157    return EGL_TRUE;
 158 }
 159
 160
 161 static EGLint
 162 _eglQueryContextRenderBuffer(_EGLContext *ctx)
 163 {
 164    _EGLSurface *surf = ctx->DrawSurface;
 165    EGLint rb;
 166
 167    if (!surf)
 168       return EGL_NONE;
 169    if (surf->Type == EGL_WINDOW_BIT && ctx->WindowRenderBuffer != EGL_NONE)
 170       rb = ctx->WindowRenderBuffer;
 171    else
 172       rb = surf->RenderBuffer;
 173    return rb;
 174 }
 175
 176
 177 EGLBoolean
 178 _eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *c,
 179                  EGLint attribute, EGLint *value)
 180 {
 181    (void) drv;
 182    (void) dpy;
 183
 184    if (!value)
 185       return _eglError(EGL_BAD_PARAMETER, "eglQueryContext");
 186
 187    switch (attribute) {
 188    case EGL_CONFIG_ID:
 189       if (!c->Config)
 190          return _eglError(EGL_BAD_ATTRIBUTE, "eglQueryContext");
 191       *value = c->Config->ConfigID;
 192       break;
 193    case EGL_CONTEXT_CLIENT_VERSION:
 194       *value = c->ClientVersion;
 195       break;
 196    case EGL_CONTEXT_CLIENT_TYPE:
 197       *value = c->ClientAPI;
 198       break;
 199    case EGL_RENDER_BUFFER:
 200       *value = _eglQueryContextRenderBuffer(c);
 201       break;
 202    default:
 203       return _eglError(EGL_BAD_ATTRIBUTE, "eglQueryContext");
 204    }
 205
 206    return EGL_TRUE;
 207 }
 208
 209
 210 /**
 211  * Bind the context to the thread and return the previous context.
 212  *
 213  * Note that the context may be NULL.
 214  */
 215 static _EGLContext *
 216 _eglBindContextToThread(_EGLContext *ctx, _EGLThreadInfo *t)
 217 {
 218    EGLint apiIndex;
 219    _EGLContext *oldCtx;
 220
 221    apiIndex = (ctx) ?
 222       _eglConvertApiToIndex(ctx->ClientAPI) : t->CurrentAPIIndex;
 223
 224    oldCtx = t->CurrentContexts[apiIndex];
 225    if (ctx != oldCtx) {
 226       if (oldCtx)
 227          oldCtx->Binding = NULL;
 228       if (ctx)
 229          ctx->Binding = t;
 230
 231       t->CurrentContexts[apiIndex] = ctx;
 232    }
 233
 234    return oldCtx;
 235 }
 236
 237
 238 /**
 239  * Return true if the given context and surfaces can be made current.
 240  */
 241 static EGLBoolean
 242 _eglCheckMakeCurrent(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read)
 243 {
 244    _EGLThreadInfo *t = _eglGetCurrentThread();
 245    _EGLDisplay *dpy;
 246    EGLint conflict_api;
 247    EGLBoolean surfaceless;
 248
 249    if (_eglIsCurrentThreadDummy())
 250       return _eglError(EGL_BAD_ALLOC, "eglMakeCurrent");
 251
 252    /* this is easy */
 253    if (!ctx) {
 254       if (draw || read)
 255          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 256       return EGL_TRUE;
 257    }
 258
 259    dpy = ctx->Resource.Display;
 260    switch (_eglGetContextAPIBit(ctx)) {
 261    case EGL_OPENGL_ES_BIT:
 262       surfaceless = dpy->Extensions.KHR_surfaceless_gles1;
 263       break;
 264    case EGL_OPENGL_ES2_BIT:
 265       surfaceless = dpy->Extensions.KHR_surfaceless_gles2;
 266       break;
 267    case EGL_OPENGL_BIT:
 268       surfaceless = dpy->Extensions.KHR_surfaceless_opengl;
 269       break;
 270    default:
 271       surfaceless = EGL_FALSE;
 272       break;
 273    }
 274
 275    if (!surfaceless && (draw == NULL || read == NULL))
 276       return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 277
 278    /*
 279     * The spec says
 280     *
 281     * "If ctx is current to some other thread, or if either draw or read are
 282     * bound to contexts in another thread, an EGL_BAD_ACCESS error is
 283     * generated."
 284     *
 285     * and
 286     *
 287     * "at most one context may be bound to a particular surface at a given
 288     * time"
 289     */
 290    if (ctx->Binding && ctx->Binding != t)
 291       return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 292    if (draw && draw->CurrentContext && draw->CurrentContext != ctx) {
 293       if (draw->CurrentContext->Binding != t ||
 294           draw->CurrentContext->ClientAPI != ctx->ClientAPI)
 295          return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 296    }
 297    if (read && read->CurrentContext && read->CurrentContext != ctx) {
 298       if (read->CurrentContext->Binding != t ||
 299           read->CurrentContext->ClientAPI != ctx->ClientAPI)
 300          return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 301    }
 302
 303    /* simply require the configs to be equal */
 304    if ((draw && draw->Config != ctx->Config) ||
 305        (read && read->Config != ctx->Config))
 306       return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 307
 308    switch (ctx->ClientAPI) {
 309    /* OpenGL and OpenGL ES are conflicting */
 310    case EGL_OPENGL_ES_API:
 311       conflict_api = EGL_OPENGL_API;
 312       break;
 313    case EGL_OPENGL_API:
 314       conflict_api = EGL_OPENGL_ES_API;
 315       break;
 316    default:
 317       conflict_api = -1;
 318       break;
 319    }
 320
 321    if (conflict_api >= 0 && _eglGetAPIContext(conflict_api))
 322       return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 323
 324    return EGL_TRUE;
 325 }
 326
 327
 328 /**
 329  * Bind the context to the current thread and given surfaces.  Return the
 330  * previous bound context and surfaces.  The caller should unreference the
 331  * returned context and surfaces.
 332  *
 333  * Making a second call with the resources returned by the first call
 334  * unsurprisingly undoes the first call, except for the resouce reference
 335  * counts.
 336  */
 337 EGLBoolean
 338 _eglBindContext(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read,
 339                 _EGLContext **old_ctx,
 340                 _EGLSurface **old_draw, _EGLSurface **old_read)
 341 {
 342    _EGLThreadInfo *t = _eglGetCurrentThread();
 343    _EGLContext *prev_ctx;
 344    _EGLSurface *prev_draw, *prev_read;
 345
 346    if (!_eglCheckMakeCurrent(ctx, draw, read))
 347       return EGL_FALSE;
 348
 349    /* increment refcounts before binding */
 350    _eglGetContext(ctx);
 351    _eglGetSurface(draw);
 352    _eglGetSurface(read);
 353
 354    /* bind the new context */
 355    prev_ctx = _eglBindContextToThread(ctx, t);
 356
 357    /* break previous bindings */
 358    if (prev_ctx) {
 359       prev_draw = prev_ctx->DrawSurface;
 360       prev_read = prev_ctx->ReadSurface;
 361
 362       if (prev_draw)
 363          prev_draw->CurrentContext = NULL;
 364       if (prev_read)
 365          prev_read->CurrentContext = NULL;
 366
 367       prev_ctx->DrawSurface = NULL;
 368       prev_ctx->ReadSurface = NULL;
 369    }
 370    else {
 371       prev_draw = prev_read = NULL;
 372    }
 373
 374    /* establish new bindings */
 375    if (ctx) {
 376       if (draw)
 377          draw->CurrentContext = ctx;
 378       if (read)
 379          read->CurrentContext = ctx;
 380
 381       ctx->DrawSurface = draw;
 382       ctx->ReadSurface = read;
 383    }
 384
 385    assert(old_ctx && old_draw && old_read);
 386    *old_ctx = prev_ctx;
 387    *old_draw = prev_draw;
 388    *old_read = prev_read;
 389
 390    return EGL_TRUE;
 391 }