src/egl/main/eglcontext.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2008 VMware, Inc.
   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->ClientMajorVersion) {
  53       case 1:
  54          bit = EGL_OPENGL_ES_BIT;
  55          break;
  56       case 2:
  57          bit = EGL_OPENGL_ES2_BIT;
  58          break;
  59       case 3:
  60          bit = EGL_OPENGL_ES3_BIT_KHR;
  61          break;
  62       default:
  63          break;
  64       }
  65       break;
  66    case EGL_OPENVG_API:
  67       bit = EGL_OPENVG_BIT;
  68       break;
  69    case EGL_OPENGL_API:
  70       bit = EGL_OPENGL_BIT;
  71       break;
  72    default:
  73       break;
  74    }
  75
  76    return bit;
  77 }
  78
  79
  80 /**
  81  * Parse the list of context attributes and return the proper error code.
  82  */
  83 static EGLint
  84 _eglParseContextAttribList(_EGLContext *ctx, _EGLDisplay *dpy,
  85                            const EGLint *attrib_list)
  86 {
  87    EGLenum api = ctx->ClientAPI;
  88    EGLint i, err = EGL_SUCCESS;
  89
  90    if (!attrib_list)
  91       return EGL_SUCCESS;
  92
  93    if (api == EGL_OPENVG_API && attrib_list[0] != EGL_NONE) {
  94       _eglLog(_EGL_DEBUG, "bad context attribute 0x%04x", attrib_list[0]);
  95       return EGL_BAD_ATTRIBUTE;
  96    }
  97
  98    for (i = 0; attrib_list[i] != EGL_NONE; i++) {
  99       EGLint attr = attrib_list[i++];
 100       EGLint val = attrib_list[i];
 101
 102       switch (attr) {
 103       case EGL_CONTEXT_CLIENT_VERSION:
 104          /* The EGL 1.4 spec says:
 105           *
 106           *     "attribute EGL_CONTEXT_CLIENT_VERSION is only valid when the
 107           *      current rendering API is EGL_OPENGL_ES_API"
 108           *
 109           * The EGL_KHR_create_context spec says:
 110           *
 111           *     "EGL_CONTEXT_MAJOR_VERSION_KHR           0x3098
 112           *      (this token is an alias for EGL_CONTEXT_CLIENT_VERSION)"
 113           *
 114           *     "The values for attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
 115           *      EGL_CONTEXT_MINOR_VERSION_KHR specify the requested client API
 116           *      version. They are only meaningful for OpenGL and OpenGL ES
 117           *      contexts, and specifying them for other types of contexts will
 118           *      generate an error."
 119           */
 120          if ((api != EGL_OPENGL_ES_API &&
 121              (!dpy->Extensions.KHR_create_context || api != EGL_OPENGL_API))) {
 122                err = EGL_BAD_ATTRIBUTE;
 123                break;
 124          }
 125
 126          ctx->ClientMajorVersion = val;
 127          break;
 128
 129       case EGL_CONTEXT_MINOR_VERSION_KHR:
 130          /* The EGL_KHR_create_context spec says:
 131           *
 132           *     "The values for attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
 133           *      EGL_CONTEXT_MINOR_VERSION_KHR specify the requested client API
 134           *      version. They are only meaningful for OpenGL and OpenGL ES
 135           *      contexts, and specifying them for other types of contexts will
 136           *      generate an error."
 137           */
 138          if (!dpy->Extensions.KHR_create_context ||
 139              (api != EGL_OPENGL_ES_API && api != EGL_OPENGL_API)) {
 140             err = EGL_BAD_ATTRIBUTE;
 141             break;
 142          }
 143
 144          ctx->ClientMinorVersion = val;
 145          break;
 146
 147       case EGL_CONTEXT_FLAGS_KHR:
 148          if (!dpy->Extensions.KHR_create_context) {
 149             err = EGL_BAD_ATTRIBUTE;
 150             break;
 151          }
 152
 153          /* The EGL_KHR_create_context spec says:
 154           *
 155           *     "If the EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR flag bit is set in
 156           *     EGL_CONTEXT_FLAGS_KHR, then a <debug context> will be created.
 157           *     [...]
 158           *     In some cases a debug context may be identical to a non-debug
 159           *     context. This bit is supported for OpenGL and OpenGL ES
 160           *     contexts."
 161           */
 162          if ((val & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR) &&
 163              (api != EGL_OPENGL_API && api != EGL_OPENGL_ES_API)) {
 164             err = EGL_BAD_ATTRIBUTE;
 165             break;
 166          }
 167
 168          /* The EGL_KHR_create_context spec says:
 169           *
 170           *     "If the EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR flag bit
 171           *     is set in EGL_CONTEXT_FLAGS_KHR, then a <forward-compatible>
 172           *     context will be created. Forward-compatible contexts are
 173           *     defined only for OpenGL versions 3.0 and later. They must not
 174           *     support functionality marked as <deprecated> by that version of
 175           *     the API, while a non-forward-compatible context must support
 176           *     all functionality in that version, deprecated or not. This bit
 177           *     is supported for OpenGL contexts, and requesting a
 178           *     forward-compatible context for OpenGL versions less than 3.0
 179           *     will generate an error."
 180           */
 181          if ((val & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) &&
 182              (api != EGL_OPENGL_API || ctx->ClientMajorVersion < 3)) {
 183             err = EGL_BAD_ATTRIBUTE;
 184             break;
 185          }
 186
 187          if ((val & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR) &&
 188              api != EGL_OPENGL_API) {
 189             /* The EGL_KHR_create_context spec says:
 190              *
 191              *   10) Which error should be generated if robust buffer access
 192              *       or reset notifications are requested under OpenGL ES?
 193              *
 194              *       As per Issue 6, this extension does not support creating
 195              *       robust contexts for OpenGL ES. This is only supported via
 196              *       the EGL_EXT_create_context_robustness extension.
 197              *
 198              *       Attempting to use this extension to create robust OpenGL
 199              *       ES context will generate an EGL_BAD_ATTRIBUTE error. This
 200              *       specific error is generated because this extension does
 201              *       not define the EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR
 202              *       and EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR
 203              *       bits for OpenGL ES contexts. Thus, use of these bits fall
 204              *       under condition described by: "If an attribute is
 205              *       specified that is not meaningful for the client API
 206              *       type.." in the above specification.
 207              *
 208              * The spec requires that we emit the error even if the display
 209              * supports EGL_EXT_create_context_robustness. To create a robust
 210              * GLES context, the *attribute*
 211              * EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT must be used, not the
 212              * *flag* EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR.
 213              */
 214             err = EGL_BAD_ATTRIBUTE;
 215             break;
 216          }
 217
 218          ctx->Flags |= val;
 219          break;
 220
 221       case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
 222          if (!dpy->Extensions.KHR_create_context) {
 223             err = EGL_BAD_ATTRIBUTE;
 224             break;
 225          }
 226
 227          /* The EGL_KHR_create_context spec says:
 228           *
 229           *     "[EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR] is only meaningful for
 230           *     OpenGL contexts, and specifying it for other types of
 231           *     contexts, including OpenGL ES contexts, will generate an
 232           *     error."
 233           */
 234          if (api != EGL_OPENGL_API) {
 235             err = EGL_BAD_ATTRIBUTE;
 236             break;
 237          }
 238
 239          ctx->Profile = val;
 240          break;
 241
 242       case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR:
 243          /* The EGL_KHR_create_context spec says:
 244           *
 245           *     "[EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR] is only
 246           *     meaningful for OpenGL contexts, and specifying it for other
 247           *     types of contexts, including OpenGL ES contexts, will generate
 248           *     an error."
 249           */
 250            if (!dpy->Extensions.KHR_create_context
 251                || api != EGL_OPENGL_API) {
 252             err = EGL_BAD_ATTRIBUTE;
 253             break;
 254          }
 255
 256          ctx->ResetNotificationStrategy = val;
 257          break;
 258
 259       case EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT:
 260          /* The EGL_EXT_create_context_robustness spec says:
 261           *
 262           *     "[EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT] is only
 263           *     meaningful for OpenGL ES contexts, and specifying it for other
 264           *     types of contexts will generate an EGL_BAD_ATTRIBUTE error."
 265           */
 266          if (!dpy->Extensions.EXT_create_context_robustness
 267              || api != EGL_OPENGL_ES_API) {
 268             err = EGL_BAD_ATTRIBUTE;
 269             break;
 270          }
 271
 272          ctx->ResetNotificationStrategy = val;
 273          break;
 274
 275       case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
 276          if (!dpy->Extensions.EXT_create_context_robustness) {
 277             err = EGL_BAD_ATTRIBUTE;
 278             break;
 279          }
 280
 281          if (val == EGL_TRUE)
 282             ctx->Flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
 283          break;
 284
 285       case EGL_CONTEXT_OPENGL_ROBUST_ACCESS:
 286          if (dpy->Version < 15) {
 287             err = EGL_BAD_ATTRIBUTE;
 288             break;
 289          }
 290
 291          if (val == EGL_TRUE)
 292             ctx->Flags |= EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR;
 293          break;
 294
 295       case EGL_CONTEXT_OPENGL_DEBUG:
 296          if (dpy->Version < 15) {
 297             err = EGL_BAD_ATTRIBUTE;
 298             break;
 299          }
 300
 301          if (val == EGL_TRUE)
 302             ctx->Flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
 303          break;
 304
 305       case EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE:
 306          if (dpy->Version < 15) {
 307             err = EGL_BAD_ATTRIBUTE;
 308             break;
 309          }
 310
 311          if (val == EGL_TRUE)
 312             ctx->Flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
 313          break;
 314
 315       case EGL_CONTEXT_OPENGL_NO_ERROR_KHR:
 316          if (dpy->Version < 14 ||
 317              !dpy->Extensions.KHR_create_context_no_error) {
 318             err = EGL_BAD_ATTRIBUTE;
 319             break;
 320          }
 321
 322          /* The KHR_no_error spec only applies against OpenGL 2.0+ and
 323           * OpenGL ES 2.0+
 324           */
 325          if ((api != EGL_OPENGL_API && api != EGL_OPENGL_ES_API) ||
 326              ctx->ClientMajorVersion < 2) {
 327             err = EGL_BAD_ATTRIBUTE;
 328             break;
 329          }
 330
 331          /* Canonicalize value to EGL_TRUE/EGL_FALSE definitions */
 332          ctx->NoError = !!val;
 333          break;
 334
 335       case EGL_CONTEXT_PRIORITY_LEVEL_IMG:
 336          /* The  EGL_IMG_context_priority spec says:
 337           *
 338           * "EGL_CONTEXT_PRIORITY_LEVEL_IMG determines the priority level of
 339           * the context to be created. This attribute is a hint, as an
 340           * implementation may not support multiple contexts at some
 341           * priority levels and system policy may limit access to high
 342           * priority contexts to appropriate system privilege level. The
 343           * default value for EGL_CONTEXT_PRIORITY_LEVEL_IMG is
 344           * EGL_CONTEXT_PRIORITY_MEDIUM_IMG."
 345           */
 346          {
 347             int bit;
 348
 349             switch (val) {
 350             case EGL_CONTEXT_PRIORITY_HIGH_IMG:
 351                bit = __EGL_CONTEXT_PRIORITY_HIGH_BIT;
 352                break;
 353             case EGL_CONTEXT_PRIORITY_MEDIUM_IMG:
 354                bit = __EGL_CONTEXT_PRIORITY_MEDIUM_BIT;
 355                break;
 356             case EGL_CONTEXT_PRIORITY_LOW_IMG:
 357                bit = __EGL_CONTEXT_PRIORITY_LOW_BIT;
 358                break;
 359             default:
 360                bit = -1;
 361                break;
 362             }
 363
 364             if (bit < 0) {
 365                err = EGL_BAD_ATTRIBUTE;
 366                break;
 367             }
 368
 369             /* "This extension allows an EGLContext to be created with a
 370              * priority hint. It is possible that an implementation will not
 371              * honour the hint, especially if there are constraints on the
 372              * number of high priority contexts available in the system, or
 373              * system policy limits access to high priority contexts to
 374              * appropriate system privilege level. A query is provided to find
 375              * the real priority level assigned to the context after creation."
 376              *
 377              * We currently assume that the driver applies the priority hint
 378              * and filters out any it cannot handle during the screen setup,
 379              * e.g. dri2_setup_screen(). As such we can mask any change that
 380              * the driver would fail, and ctx->ContextPriority matches the
 381              * hint applied to the driver/hardware backend.
 382              */
 383             if (dpy->Extensions.IMG_context_priority & (1 << bit))
 384                ctx->ContextPriority = val;
 385
 386             break;
 387          }
 388
 389       case EGL_CONTEXT_RELEASE_BEHAVIOR_KHR:
 390          if (val == EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR ||
 391              val == EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR) {
 392             ctx->ReleaseBehavior = val;
 393          } else {
 394             err = EGL_BAD_ATTRIBUTE;
 395          }
 396          break;
 397
 398       default:
 399          err = EGL_BAD_ATTRIBUTE;
 400          break;
 401       }
 402
 403       if (err != EGL_SUCCESS) {
 404          _eglLog(_EGL_DEBUG, "bad context attribute 0x%04x", attr);
 405          break;
 406       }
 407    }
 408
 409    if (api == EGL_OPENGL_API) {
 410       /* The EGL_KHR_create_context spec says:
 411        *
 412        *     "If the requested OpenGL version is less than 3.2,
 413        *     EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR is ignored and the
 414        *     functionality of the context is determined solely by the
 415        *     requested version."
 416        *
 417        * Since the value is ignored, only validate the setting if the version
 418        * is >= 3.2.
 419        */
 420       if (ctx->ClientMajorVersion >= 4
 421           || (ctx->ClientMajorVersion == 3 && ctx->ClientMinorVersion >= 2)) {
 422          switch (ctx->Profile) {
 423          case EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR:
 424          case EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR:
 425             break;
 426
 427          default:
 428             /* The EGL_KHR_create_context spec says:
 429              *
 430              *     "* If an OpenGL context is requested, the requested version
 431              *        is greater than 3.2, and the value for attribute
 432              *        EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR has no bits set; has
 433              *        any bits set other than EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR
 434              *        and EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; has
 435              *        more than one of these bits set; or if the implementation does
 436              *        not support the requested profile, then an EGL_BAD_MATCH error
 437              *        is generated."
 438              */
 439             err = EGL_BAD_MATCH;
 440             break;
 441          }
 442       }
 443
 444       /* The EGL_KHR_create_context spec says:
 445        *
 446        *     "* If an OpenGL context is requested and the values for
 447        *        attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
 448        *        EGL_CONTEXT_MINOR_VERSION_KHR, when considered together with
 449        *        the value for attribute
 450        *        EGL_CONTEXT_FORWARD_COMPATIBLE_BIT_KHR, specify an OpenGL
 451        *        version and feature set that are not defined, than an
 452        *        EGL_BAD_MATCH error is generated.
 453        *
 454        *        ... Thus, examples of invalid combinations of attributes
 455        *        include:
 456        *
 457        *          - Major version < 1 or > 4
 458        *          - Major version == 1 and minor version < 0 or > 5
 459        *          - Major version == 2 and minor version < 0 or > 1
 460        *          - Major version == 3 and minor version < 0 or > 2
 461        *          - Major version == 4 and minor version < 0 or > 2
 462        *          - Forward-compatible flag set and major version < 3"
 463        */
 464       if (ctx->ClientMajorVersion < 1 || ctx->ClientMinorVersion < 0)
 465          err = EGL_BAD_MATCH;
 466
 467       switch (ctx->ClientMajorVersion) {
 468       case 1:
 469          if (ctx->ClientMinorVersion > 5
 470              || (ctx->Flags & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) != 0)
 471             err = EGL_BAD_MATCH;
 472          break;
 473
 474       case 2:
 475          if (ctx->ClientMinorVersion > 1
 476              || (ctx->Flags & EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR) != 0)
 477             err = EGL_BAD_MATCH;
 478          break;
 479
 480       case 3:
 481          /* Note: The text above is incorrect.  There *is* an OpenGL 3.3!
 482           */
 483          if (ctx->ClientMinorVersion > 3)
 484             err = EGL_BAD_MATCH;
 485          break;
 486
 487       case 4:
 488       default:
 489          /* Don't put additional version checks here.  We don't know that
 490           * there won't be versions > 4.2.
 491           */
 492          break;
 493       }
 494    } else if (api == EGL_OPENGL_ES_API) {
 495       /* The EGL_KHR_create_context spec says:
 496        *
 497        *     "* If an OpenGL ES context is requested and the values for
 498        *        attributes EGL_CONTEXT_MAJOR_VERSION_KHR and
 499        *        EGL_CONTEXT_MINOR_VERSION_KHR specify an OpenGL ES version that
 500        *        is not defined, than an EGL_BAD_MATCH error is generated.
 501        *
 502        *        ... Examples of invalid combinations of attributes include:
 503        *
 504        *          - Major version < 1 or > 2
 505        *          - Major version == 1 and minor version < 0 or > 1
 506        *          - Major version == 2 and minor version != 0
 507        */
 508       if (ctx->ClientMajorVersion < 1 || ctx->ClientMinorVersion < 0)
 509          err = EGL_BAD_MATCH;
 510
 511       switch (ctx->ClientMajorVersion) {
 512       case 1:
 513          if (ctx->ClientMinorVersion > 1)
 514             err = EGL_BAD_MATCH;
 515          break;
 516
 517       case 2:
 518          if (ctx->ClientMinorVersion > 0)
 519             err = EGL_BAD_MATCH;
 520          break;
 521
 522       case 3:
 523          /* Don't put additional version checks here.  We don't know that
 524           * there won't be versions > 3.0.
 525           */
 526          break;
 527
 528       default:
 529          err = EGL_BAD_MATCH;
 530          break;
 531       }
 532    }
 533
 534    switch (ctx->ResetNotificationStrategy) {
 535    case EGL_NO_RESET_NOTIFICATION_KHR:
 536    case EGL_LOSE_CONTEXT_ON_RESET_KHR:
 537       break;
 538
 539    default:
 540       err = EGL_BAD_ATTRIBUTE;
 541       break;
 542    }
 543
 544    /* The EGL_KHR_create_context_no_error spec says:
 545     *
 546     *    "BAD_MATCH is generated if the EGL_CONTEXT_OPENGL_NO_ERROR_KHR is TRUE at
 547     *    the same time as a debug or robustness context is specified."
 548     */
 549    if (ctx->NoError && (ctx->Flags & EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR ||
 550                         ctx->Flags & EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR)) {
 551       err = EGL_BAD_MATCH;
 552    }
 553
 554    if ((ctx->Flags & ~(EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR
 555                       | EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR
 556                       | EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR)) != 0) {
 557       err = EGL_BAD_ATTRIBUTE;
 558    }
 559
 560    return err;
 561 }
 562
 563
 564 /**
 565  * Initialize the given _EGLContext object to defaults and/or the values
 566  * in the attrib_list.
 567  *
 568  * According to EGL 1.5 Section 3.7:
 569  *
 570  *      "EGL_OPENGL_API and EGL_OPENGL_ES_API are interchangeable for all
 571  *      purposes except eglCreateContext."
 572  *
 573  * And since we only support GL and GLES, this is the only place where the
 574  * bound API matters at all. We look up the current API from the current
 575  * thread, and stash that in the context we're initializing. Our caller is
 576  * responsible for determining whether that's an API it supports.
 577  */
 578 EGLBoolean
 579 _eglInitContext(_EGLContext *ctx, _EGLDisplay *dpy, _EGLConfig *conf,
 580                 const EGLint *attrib_list)
 581 {
 582    const EGLenum api = eglQueryAPI();
 583    EGLint err;
 584
 585    if (api == EGL_NONE)
 586       return _eglError(EGL_BAD_MATCH, "eglCreateContext(no client API)");
 587
 588    _eglInitResource(&ctx->Resource, sizeof(*ctx), dpy);
 589    ctx->ClientAPI = api;
 590    ctx->Config = conf;
 591    ctx->Profile = EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
 592
 593    ctx->ClientMajorVersion = 1; /* the default, per EGL spec */
 594    ctx->ClientMinorVersion = 0;
 595    ctx->Flags = 0;
 596    ctx->ResetNotificationStrategy = EGL_NO_RESET_NOTIFICATION_KHR;
 597    ctx->ContextPriority = EGL_CONTEXT_PRIORITY_MEDIUM_IMG;
 598    ctx->ReleaseBehavior = EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR;
 599
 600    err = _eglParseContextAttribList(ctx, dpy, attrib_list);
 601    if (err == EGL_SUCCESS && ctx->Config) {
 602       EGLint api_bit;
 603
 604       api_bit = _eglGetContextAPIBit(ctx);
 605       if (!(ctx->Config->RenderableType & api_bit)) {
 606          _eglLog(_EGL_DEBUG, "context api is 0x%x while config supports 0x%x",
 607                api_bit, ctx->Config->RenderableType);
 608          err = EGL_BAD_CONFIG;
 609       }
 610    }
 611    if (err != EGL_SUCCESS)
 612       return _eglError(err, "eglCreateContext");
 613
 614    return EGL_TRUE;
 615 }
 616
 617
 618 static EGLint
 619 _eglQueryContextRenderBuffer(_EGLContext *ctx)
 620 {
 621    _EGLSurface *surf = ctx->DrawSurface;
 622
 623    /* From the EGL 1.5 spec:
 624     *
 625     *    - If the context is not bound to a surface, then EGL_NONE will be
 626     *      returned.
 627     */
 628    if (!surf)
 629       return EGL_NONE;
 630
 631    switch (surf->Type) {
 632    default:
 633       unreachable("bad EGLSurface type");
 634    case EGL_PIXMAP_BIT:
 635       /* - If the context is bound to a pixmap surface, then EGL_SINGLE_BUFFER
 636        *   will be returned.
 637        */
 638       return EGL_SINGLE_BUFFER;
 639    case EGL_PBUFFER_BIT:
 640       /* - If the context is bound to a pbuffer surface, then EGL_BACK_BUFFER
 641        *   will be returned.
 642        */
 643       return EGL_BACK_BUFFER;
 644    case EGL_WINDOW_BIT:
 645       /* - If the context is bound to a window surface, then either
 646        *   EGL_BACK_BUFFER or EGL_SINGLE_BUFFER may be returned. The value
 647        *   returned depends on both the buffer requested by the setting of the
 648        *   EGL_RENDER_BUFFER property of the surface [...], and on the client
 649        *   API (not all client APIs support single-buffer Rendering to window
 650        *   surfaces). Some client APIs allow control of whether rendering goes
 651        *   to the front or back buffer. This client API-specific choice is not
 652        *   reflected in the returned value, which only describes the buffer
 653        *   that will be rendered to by default if not overridden by the client
 654        *   API.
 655        */
 656       return surf->ActiveRenderBuffer;
 657    }
 658 }
 659
 660
 661 EGLBoolean
 662 _eglQueryContext(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *c,
 663                  EGLint attribute, EGLint *value)
 664 {
 665    (void) drv;
 666    (void) dpy;
 667
 668    if (!value)
 669       return _eglError(EGL_BAD_PARAMETER, "eglQueryContext");
 670
 671    switch (attribute) {
 672    case EGL_CONFIG_ID:
 673       /*
 674        * From EGL_KHR_no_config_context:
 675        *
 676        *    "Querying EGL_CONFIG_ID returns the ID of the EGLConfig with
 677        *     respect to which the context was created, or zero if created
 678        *     without respect to an EGLConfig."
 679        */
 680       *value = c->Config ? c->Config->ConfigID : 0;
 681       break;
 682    case EGL_CONTEXT_CLIENT_VERSION:
 683       *value = c->ClientMajorVersion;
 684       break;
 685    case EGL_CONTEXT_CLIENT_TYPE:
 686       *value = c->ClientAPI;
 687       break;
 688    case EGL_RENDER_BUFFER:
 689       *value = _eglQueryContextRenderBuffer(c);
 690       break;
 691    case EGL_CONTEXT_PRIORITY_LEVEL_IMG:
 692       *value = c->ContextPriority;
 693       break;
 694    default:
 695       return _eglError(EGL_BAD_ATTRIBUTE, "eglQueryContext");
 696    }
 697
 698    return EGL_TRUE;
 699 }
 700
 701
 702 /**
 703  * Bind the context to the thread and return the previous context.
 704  *
 705  * Note that the context may be NULL.
 706  */
 707 _EGLContext *
 708 _eglBindContextToThread(_EGLContext *ctx, _EGLThreadInfo *t)
 709 {
 710    _EGLContext *oldCtx;
 711
 712    oldCtx = t->CurrentContext;
 713    if (ctx != oldCtx) {
 714       if (oldCtx)
 715          oldCtx->Binding = NULL;
 716       if (ctx)
 717          ctx->Binding = t;
 718
 719       t->CurrentContext = ctx;
 720    }
 721
 722    return oldCtx;
 723 }
 724
 725
 726 /**
 727  * Return true if the given context and surfaces can be made current.
 728  */
 729 static EGLBoolean
 730 _eglCheckMakeCurrent(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read)
 731 {
 732    _EGLThreadInfo *t = _eglGetCurrentThread();
 733    _EGLDisplay *dpy;
 734
 735    if (_eglIsCurrentThreadDummy())
 736       return _eglError(EGL_BAD_ALLOC, "eglMakeCurrent");
 737
 738    /* this is easy */
 739    if (!ctx) {
 740       if (draw || read)
 741          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 742       return EGL_TRUE;
 743    }
 744
 745    dpy = ctx->Resource.Display;
 746    if (!dpy->Extensions.KHR_surfaceless_context
 747        && (draw == NULL || read == NULL))
 748       return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 749
 750    /*
 751     * The spec says
 752     *
 753     * "If ctx is current to some other thread, or if either draw or read are
 754     * bound to contexts in another thread, an EGL_BAD_ACCESS error is
 755     * generated."
 756     *
 757     * and
 758     *
 759     * "at most one context may be bound to a particular surface at a given
 760     * time"
 761     */
 762    if (ctx->Binding && ctx->Binding != t)
 763       return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 764    if (draw && draw->CurrentContext && draw->CurrentContext != ctx) {
 765       if (draw->CurrentContext->Binding != t)
 766          return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 767    }
 768    if (read && read->CurrentContext && read->CurrentContext != ctx) {
 769       if (read->CurrentContext->Binding != t)
 770          return _eglError(EGL_BAD_ACCESS, "eglMakeCurrent");
 771    }
 772
 773    /* If the context has a config then it must match that of the two
 774     * surfaces */
 775    if (ctx->Config) {
 776       if ((draw && draw->Config != ctx->Config) ||
 777           (read && read->Config != ctx->Config))
 778          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 779    } else {
 780       /* Otherwise we must be using the EGL_KHR_no_config_context
 781        * extension */
 782       assert(dpy->Extensions.KHR_no_config_context);
 783
 784       /* The extension doesn't permit binding draw and read buffers with
 785        * differing contexts */
 786       if (draw && read && draw->Config != read->Config)
 787          return _eglError(EGL_BAD_MATCH, "eglMakeCurrent");
 788    }
 789
 790    return EGL_TRUE;
 791 }
 792
 793
 794 /**
 795  * Bind the context to the current thread and given surfaces.  Return the
 796  * previous bound context and surfaces.  The caller should unreference the
 797  * returned context and surfaces.
 798  *
 799  * Making a second call with the resources returned by the first call
 800  * unsurprisingly undoes the first call, except for the resouce reference
 801  * counts.
 802  */
 803 EGLBoolean
 804 _eglBindContext(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read,
 805                 _EGLContext **old_ctx,
 806                 _EGLSurface **old_draw, _EGLSurface **old_read)
 807 {
 808    _EGLThreadInfo *t = _eglGetCurrentThread();
 809    _EGLContext *prev_ctx;
 810    _EGLSurface *prev_draw, *prev_read;
 811
 812    if (!_eglCheckMakeCurrent(ctx, draw, read))
 813       return EGL_FALSE;
 814
 815    /* increment refcounts before binding */
 816    _eglGetContext(ctx);
 817    _eglGetSurface(draw);
 818    _eglGetSurface(read);
 819
 820    /* bind the new context */
 821    prev_ctx = _eglBindContextToThread(ctx, t);
 822
 823    /* break previous bindings */
 824    if (prev_ctx) {
 825       prev_draw = prev_ctx->DrawSurface;
 826       prev_read = prev_ctx->ReadSurface;
 827
 828       if (prev_draw)
 829          prev_draw->CurrentContext = NULL;
 830       if (prev_read)
 831          prev_read->CurrentContext = NULL;
 832
 833       prev_ctx->DrawSurface = NULL;
 834       prev_ctx->ReadSurface = NULL;
 835    }
 836    else {
 837       prev_draw = prev_read = NULL;
 838    }
 839
 840    /* establish new bindings */
 841    if (ctx) {
 842       if (draw)
 843          draw->CurrentContext = ctx;
 844       if (read)
 845          read->CurrentContext = ctx;
 846
 847       ctx->DrawSurface = draw;
 848       ctx->ReadSurface = read;
 849    }
 850
 851    assert(old_ctx && old_draw && old_read);
 852    *old_ctx = prev_ctx;
 853    *old_draw = prev_draw;
 854    *old_read = prev_read;
 855
 856    return EGL_TRUE;
 857 }