src/mesa/main/context.c

   1 /**
   2  * \file context.c
   3  * Mesa context/visual/framebuffer management functions.
   4  * \author Brian Paul
   5  */
   6
   7 /*
   8  * Mesa 3-D graphics library
   9  * Version:  7.1
  10  *
  11  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining a
  14  * copy of this software and associated documentation files (the "Software"),
  15  * to deal in the Software without restriction, including without limitation
  16  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  17  * and/or sell copies of the Software, and to permit persons to whom the
  18  * Software is furnished to do so, subject to the following conditions:
  19  *
  20  * The above copyright notice and this permission notice shall be included
  21  * in all copies or substantial portions of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  24  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  25  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  26  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  27  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  28  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29  */
  30
  31
  32 /**
  33  * \mainpage Mesa Main Module
  34  *
  35  * \section MainIntroduction Introduction
  36  *
  37  * The Mesa Main module consists of all the files in the main/ directory.
  38  * Among the features of this module are:
  39  * <UL>
  40  * <LI> Structures to represent most GL state </LI>
  41  * <LI> State set/get functions </LI>
  42  * <LI> Display lists </LI>
  43  * <LI> Texture unit, object and image handling </LI>
  44  * <LI> Matrix and attribute stacks </LI>
  45  * </UL>
  46  *
  47  * Other modules are responsible for API dispatch, vertex transformation,
  48  * point/line/triangle setup, rasterization, vertex array caching,
  49  * vertex/fragment programs/shaders, etc.
  50  *
  51  *
  52  * \section AboutDoxygen About Doxygen
  53  *
  54  * If you're viewing this information as Doxygen-generated HTML you'll
  55  * see the documentation index at the top of this page.
  56  *
  57  * The first line lists the Mesa source code modules.
  58  * The second line lists the indexes available for viewing the documentation
  59  * for each module.
  60  *
  61  * Selecting the <b>Main page</b> link will display a summary of the module
  62  * (this page).
  63  *
  64  * Selecting <b>Data Structures</b> will list all C structures.
  65  *
  66  * Selecting the <b>File List</b> link will list all the source files in
  67  * the module.
  68  * Selecting a filename will show a list of all functions defined in that file.
  69  *
  70  * Selecting the <b>Data Fields</b> link will display a list of all
  71  * documented structure members.
  72  *
  73  * Selecting the <b>Globals</b> link will display a list
  74  * of all functions, structures, global variables and macros in the module.
  75  *
  76  */
  77
  78
  79 #include "glheader.h"
  80 #include "imports.h"
  81 #include "accum.h"
  82 #include "arrayobj.h"
  83 #include "attrib.h"
  84 #include "blend.h"
  85 #include "buffers.h"
  86 #include "bufferobj.h"
  87 #include "colortab.h"
  88 #include "context.h"
  89 #include "debug.h"
  90 #include "depth.h"
  91 #include "dlist.h"
  92 #include "eval.h"
  93 #include "enums.h"
  94 #include "extensions.h"
  95 #include "fbobject.h"
  96 #include "feedback.h"
  97 #include "fog.h"
  98 #include "framebuffer.h"
  99 #include "get.h"
 100 #include "histogram.h"
 101 #include "hint.h"
 102 #include "hash.h"
 103 #include "light.h"
 104 #include "lines.h"
 105 #include "macros.h"
 106 #include "matrix.h"
 107 #include "pixel.h"
 108 #include "points.h"
 109 #include "polygon.h"
 110 #include "queryobj.h"
 111 #include "rastpos.h"
 112 #include "simple_list.h"
 113 #include "state.h"
 114 #include "stencil.h"
 115 #include "texcompress.h"
 116 #include "teximage.h"
 117 #include "texobj.h"
 118 #include "texstate.h"
 119 #include "mtypes.h"
 120 #include "varray.h"
 121 #include "version.h"
 122 #include "vtxfmt.h"
 123 #include "glapi/glthread.h"
 124 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 125 #include "shader/program.h"
 126 #endif
 127 #include "shader/shader_api.h"
 128 #include "shader/atifragshader.h"
 129 #if _HAVE_FULL_GL
 130 #include "math/m_translate.h"
 131 #include "math/m_matrix.h"
 132 #include "math/m_xform.h"
 133 #include "math/mathmod.h"
 134 #endif
 135
 136 #ifdef USE_SPARC_ASM
 137 #include "sparc/sparc.h"
 138 #endif
 139
 140 #ifndef MESA_VERBOSE
 141 int MESA_VERBOSE = 0;
 142 #endif
 143
 144 #ifndef MESA_DEBUG_FLAGS
 145 int MESA_DEBUG_FLAGS = 0;
 146 #endif
 147
 148
 149 /* ubyte -> float conversion */
 150 GLfloat _mesa_ubyte_to_float_color_tab[256];
 151
 152 static void
 153 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss );
 154
 155
 156 /**
 157  * Swap buffers notification callback.
 158  *
 159  * \param gc GL context.
 160  *
 161  * Called by window system just before swapping buffers.
 162  * We have to finish any pending rendering.
 163  */
 164 void
 165 _mesa_notifySwapBuffers(__GLcontext *gc)
 166 {
 167    FLUSH_VERTICES( gc, 0 );
 168 }
 169
 170
 171 /**********************************************************************/
 172 /** \name GL Visual allocation/destruction                            */
 173 /**********************************************************************/
 174 /*@{*/
 175
 176 /**
 177  * Allocates a GLvisual structure and initializes it via
 178  * _mesa_initialize_visual().
 179  *
 180  * \param rgbFlag GL_TRUE for RGB(A) mode, GL_FALSE for Color Index mode.
 181  * \param dbFlag double buffering
 182  * \param stereoFlag stereo buffer
 183  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
 184  * is acceptable but the actual depth type will be GLushort or GLuint as
 185  * needed.
 186  * \param stencilBits requested minimum bits per stencil buffer value
 187  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
 188  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
 189  * \param redBits number of bits per color component in frame buffer for RGB(A)
 190  * mode.  We always use 8 in core Mesa though.
 191  * \param greenBits same as above.
 192  * \param blueBits same as above.
 193  * \param alphaBits same as above.
 194  * \param numSamples not really used.
 195  *
 196  * \return pointer to new GLvisual or NULL if requested parameters can't be
 197  * met.
 198  *
 199  * \note Need to add params for level and numAuxBuffers (at least)
 200  */
 201 GLvisual *
 202 _mesa_create_visual( GLboolean rgbFlag,
 203                      GLboolean dbFlag,
 204                      GLboolean stereoFlag,
 205                      GLint redBits,
 206                      GLint greenBits,
 207                      GLint blueBits,
 208                      GLint alphaBits,
 209                      GLint indexBits,
 210                      GLint depthBits,
 211                      GLint stencilBits,
 212                      GLint accumRedBits,
 213                      GLint accumGreenBits,
 214                      GLint accumBlueBits,
 215                      GLint accumAlphaBits,
 216                      GLint numSamples )
 217 {
 218    GLvisual *vis = (GLvisual *) _mesa_calloc(sizeof(GLvisual));
 219    if (vis) {
 220       if (!_mesa_initialize_visual(vis, rgbFlag, dbFlag, stereoFlag,
 221                                    redBits, greenBits, blueBits, alphaBits,
 222                                    indexBits, depthBits, stencilBits,
 223                                    accumRedBits, accumGreenBits,
 224                                    accumBlueBits, accumAlphaBits,
 225                                    numSamples)) {
 226          _mesa_free(vis);
 227          return NULL;
 228       }
 229    }
 230    return vis;
 231 }
 232
 233 /**
 234  * Makes some sanity checks and fills in the fields of the
 235  * GLvisual object with the given parameters.  If the caller needs
 236  * to set additional fields, he should just probably init the whole GLvisual
 237  * object himself.
 238  * \return GL_TRUE on success, or GL_FALSE on failure.
 239  *
 240  * \sa _mesa_create_visual() above for the parameter description.
 241  */
 242 GLboolean
 243 _mesa_initialize_visual( GLvisual *vis,
 244                          GLboolean rgbFlag,
 245                          GLboolean dbFlag,
 246                          GLboolean stereoFlag,
 247                          GLint redBits,
 248                          GLint greenBits,
 249                          GLint blueBits,
 250                          GLint alphaBits,
 251                          GLint indexBits,
 252                          GLint depthBits,
 253                          GLint stencilBits,
 254                          GLint accumRedBits,
 255                          GLint accumGreenBits,
 256                          GLint accumBlueBits,
 257                          GLint accumAlphaBits,
 258                          GLint numSamples )
 259 {
 260    assert(vis);
 261
 262    if (depthBits < 0 || depthBits > 32) {
 263       return GL_FALSE;
 264    }
 265    if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
 266       return GL_FALSE;
 267    }
 268    assert(accumRedBits >= 0);
 269    assert(accumGreenBits >= 0);
 270    assert(accumBlueBits >= 0);
 271    assert(accumAlphaBits >= 0);
 272
 273    vis->rgbMode          = rgbFlag;
 274    vis->doubleBufferMode = dbFlag;
 275    vis->stereoMode       = stereoFlag;
 276
 277    vis->redBits          = redBits;
 278    vis->greenBits        = greenBits;
 279    vis->blueBits         = blueBits;
 280    vis->alphaBits        = alphaBits;
 281    vis->rgbBits          = redBits + greenBits + blueBits;
 282
 283    vis->indexBits      = indexBits;
 284    vis->depthBits      = depthBits;
 285    vis->stencilBits    = stencilBits;
 286
 287    vis->accumRedBits   = accumRedBits;
 288    vis->accumGreenBits = accumGreenBits;
 289    vis->accumBlueBits  = accumBlueBits;
 290    vis->accumAlphaBits = accumAlphaBits;
 291
 292    vis->haveAccumBuffer   = accumRedBits > 0;
 293    vis->haveDepthBuffer   = depthBits > 0;
 294    vis->haveStencilBuffer = stencilBits > 0;
 295
 296    vis->numAuxBuffers = 0;
 297    vis->level = 0;
 298    vis->pixmapMode = 0;
 299    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
 300    vis->samples = numSamples;
 301
 302    return GL_TRUE;
 303 }
 304
 305
 306 /**
 307  * Destroy a visual and free its memory.
 308  *
 309  * \param vis visual.
 310  *
 311  * Frees the visual structure.
 312  */
 313 void
 314 _mesa_destroy_visual( GLvisual *vis )
 315 {
 316    _mesa_free(vis);
 317 }
 318
 319 /*@}*/
 320
 321
 322 /**********************************************************************/
 323 /** \name Context allocation, initialization, destroying
 324  *
 325  * The purpose of the most initialization functions here is to provide the
 326  * default state values according to the OpenGL specification.
 327  */
 328 /**********************************************************************/
 329 /*@{*/
 330
 331 /**
 332  * One-time initialization mutex lock.
 333  *
 334  * \sa Used by one_time_init().
 335  */
 336 _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
 337
 338 /**
 339  * Calls all the various one-time-init functions in Mesa.
 340  *
 341  * While holding a global mutex lock, calls several initialization functions,
 342  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
 343  * defined.
 344  *
 345  * \sa _math_init().
 346  */
 347 static void
 348 one_time_init( GLcontext *ctx )
 349 {
 350    static GLboolean alreadyCalled = GL_FALSE;
 351    (void) ctx;
 352    _glthread_LOCK_MUTEX(OneTimeLock);
 353    if (!alreadyCalled) {
 354       GLuint i;
 355
 356       /* do some implementation tests */
 357       assert( sizeof(GLbyte) == 1 );
 358       assert( sizeof(GLubyte) == 1 );
 359       assert( sizeof(GLshort) == 2 );
 360       assert( sizeof(GLushort) == 2 );
 361       assert( sizeof(GLint) == 4 );
 362       assert( sizeof(GLuint) == 4 );
 363
 364       _mesa_init_sqrt_table();
 365
 366 #if _HAVE_FULL_GL
 367       _math_init();
 368
 369       for (i = 0; i < 256; i++) {
 370          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
 371       }
 372 #endif
 373
 374 #ifdef USE_SPARC_ASM
 375       _mesa_init_sparc_glapi_relocs();
 376 #endif
 377       if (_mesa_getenv("MESA_DEBUG")) {
 378          _glapi_noop_enable_warnings(GL_TRUE);
 379          _glapi_set_warning_func( (_glapi_warning_func) _mesa_warning );
 380       }
 381       else {
 382          _glapi_noop_enable_warnings(GL_FALSE);
 383       }
 384
 385 #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
 386       _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
 387                   MESA_VERSION_STRING, __DATE__, __TIME__);
 388 #endif
 389
 390       alreadyCalled = GL_TRUE;
 391    }
 392    _glthread_UNLOCK_MUTEX(OneTimeLock);
 393 }
 394
 395
 396 /**
 397  * Allocate and initialize a shared context state structure.
 398  * Initializes the display list, texture objects and vertex programs hash
 399  * tables, allocates the texture objects. If it runs out of memory, frees
 400  * everything already allocated before returning NULL.
 401  *
 402  * \return pointer to a gl_shared_state structure on success, or NULL on
 403  * failure.
 404  */
 405 static GLboolean
 406 alloc_shared_state( GLcontext *ctx )
 407 {
 408    struct gl_shared_state *ss = CALLOC_STRUCT(gl_shared_state);
 409    if (!ss)
 410       return GL_FALSE;
 411
 412    ctx->Shared = ss;
 413
 414    _glthread_INIT_MUTEX(ss->Mutex);
 415
 416    ss->DisplayList = _mesa_NewHashTable();
 417    ss->TexObjects = _mesa_NewHashTable();
 418 #if FEATURE_NV_vertex_program || FEATURE_NV_fragment_program
 419    ss->Programs = _mesa_NewHashTable();
 420 #endif
 421
 422 #if FEATURE_ARB_vertex_program
 423    ss->DefaultVertexProgram = ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 0);
 424    if (!ss->DefaultVertexProgram)
 425       goto cleanup;
 426 #endif
 427 #if FEATURE_ARB_fragment_program
 428    ss->DefaultFragmentProgram = ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 0);
 429    if (!ss->DefaultFragmentProgram)
 430       goto cleanup;
 431 #endif
 432 #if FEATURE_ATI_fragment_shader
 433    ss->ATIShaders = _mesa_NewHashTable();
 434    ss->DefaultFragmentShader = _mesa_new_ati_fragment_shader(ctx, 0);
 435    if (!ss->DefaultFragmentShader)
 436       goto cleanup;
 437 #endif
 438
 439 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
 440    ss->BufferObjects = _mesa_NewHashTable();
 441 #endif
 442
 443    ss->ArrayObjects = _mesa_NewHashTable();
 444
 445 #if FEATURE_ARB_shader_objects
 446    ss->ShaderObjects = _mesa_NewHashTable();
 447 #endif
 448
 449    ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
 450    if (!ss->Default1D)
 451       goto cleanup;
 452
 453    ss->Default2D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D);
 454    if (!ss->Default2D)
 455       goto cleanup;
 456
 457    ss->Default3D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_3D);
 458    if (!ss->Default3D)
 459       goto cleanup;
 460
 461    ss->DefaultCubeMap = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_CUBE_MAP_ARB);
 462    if (!ss->DefaultCubeMap)
 463       goto cleanup;
 464
 465    ss->DefaultRect = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_RECTANGLE_NV);
 466    if (!ss->DefaultRect)
 467       goto cleanup;
 468
 469    ss->Default1DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D_ARRAY_EXT);
 470    if (!ss->Default1DArray)
 471       goto cleanup;
 472
 473    ss->Default2DArray = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_2D_ARRAY_EXT);
 474    if (!ss->Default2DArray)
 475       goto cleanup;
 476
 477    /* sanity check */
 478    assert(ss->Default1D->RefCount == 1);
 479
 480    _glthread_INIT_MUTEX(ss->TexMutex);
 481    ss->TextureStateStamp = 0;
 482
 483 #if FEATURE_EXT_framebuffer_object
 484    ss->FrameBuffers = _mesa_NewHashTable();
 485    if (!ss->FrameBuffers)
 486       goto cleanup;
 487    ss->RenderBuffers = _mesa_NewHashTable();
 488    if (!ss->RenderBuffers)
 489       goto cleanup;
 490 #endif
 491
 492    return GL_TRUE;
 493
 494 cleanup:
 495    /* Ran out of memory at some point.  Free everything and return NULL */
 496    if (ss->DisplayList)
 497       _mesa_DeleteHashTable(ss->DisplayList);
 498    if (ss->TexObjects)
 499       _mesa_DeleteHashTable(ss->TexObjects);
 500 #if FEATURE_NV_vertex_program
 501    if (ss->Programs)
 502       _mesa_DeleteHashTable(ss->Programs);
 503 #endif
 504 #if FEATURE_ARB_vertex_program
 505    if (ss->DefaultVertexProgram)
 506       ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
 507 #endif
 508 #if FEATURE_ARB_fragment_program
 509    if (ss->DefaultFragmentProgram)
 510       ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
 511 #endif
 512 #if FEATURE_ATI_fragment_shader
 513    if (ss->DefaultFragmentShader)
 514       _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
 515 #endif
 516 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
 517    if (ss->BufferObjects)
 518       _mesa_DeleteHashTable(ss->BufferObjects);
 519 #endif
 520
 521    if (ss->ArrayObjects)
 522       _mesa_DeleteHashTable (ss->ArrayObjects);
 523
 524 #if FEATURE_ARB_shader_objects
 525    if (ss->ShaderObjects)
 526       _mesa_DeleteHashTable (ss->ShaderObjects);
 527 #endif
 528
 529 #if FEATURE_EXT_framebuffer_object
 530    if (ss->FrameBuffers)
 531       _mesa_DeleteHashTable(ss->FrameBuffers);
 532    if (ss->RenderBuffers)
 533       _mesa_DeleteHashTable(ss->RenderBuffers);
 534 #endif
 535
 536    if (ss->Default1D)
 537       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
 538    if (ss->Default2D)
 539       (*ctx->Driver.DeleteTexture)(ctx, ss->Default2D);
 540    if (ss->Default3D)
 541       (*ctx->Driver.DeleteTexture)(ctx, ss->Default3D);
 542    if (ss->DefaultCubeMap)
 543       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultCubeMap);
 544    if (ss->DefaultRect)
 545       (*ctx->Driver.DeleteTexture)(ctx, ss->DefaultRect);
 546    if (ss->Default1DArray)
 547       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1DArray);
 548    if (ss->Default2DArray)
 549       (*ctx->Driver.DeleteTexture)(ctx, ss->Default2DArray);
 550
 551    _mesa_free(ss);
 552
 553    return GL_FALSE;
 554 }
 555
 556
 557 /**
 558  * Callback for deleting a display list.  Called by _mesa_HashDeleteAll().
 559  */
 560 static void
 561 delete_displaylist_cb(GLuint id, void *data, void *userData)
 562 {
 563    struct mesa_display_list *list = (struct mesa_display_list *) data;
 564    GLcontext *ctx = (GLcontext *) userData;
 565    _mesa_delete_list(ctx, list);
 566 }
 567
 568 /**
 569  * Callback for deleting a texture object.  Called by _mesa_HashDeleteAll().
 570  */
 571 static void
 572 delete_texture_cb(GLuint id, void *data, void *userData)
 573 {
 574    struct gl_texture_object *texObj = (struct gl_texture_object *) data;
 575    GLcontext *ctx = (GLcontext *) userData;
 576    ctx->Driver.DeleteTexture(ctx, texObj);
 577 }
 578
 579 /**
 580  * Callback for deleting a program object.  Called by _mesa_HashDeleteAll().
 581  */
 582 static void
 583 delete_program_cb(GLuint id, void *data, void *userData)
 584 {
 585    struct gl_program *prog = (struct gl_program *) data;
 586    GLcontext *ctx = (GLcontext *) userData;
 587    ctx->Driver.DeleteProgram(ctx, prog);
 588 }
 589
 590 /**
 591  * Callback for deleting an ATI fragment shader object.
 592  * Called by _mesa_HashDeleteAll().
 593  */
 594 static void
 595 delete_fragshader_cb(GLuint id, void *data, void *userData)
 596 {
 597    struct ati_fragment_shader *shader = (struct ati_fragment_shader *) data;
 598    GLcontext *ctx = (GLcontext *) userData;
 599    _mesa_delete_ati_fragment_shader(ctx, shader);
 600 }
 601
 602 /**
 603  * Callback for deleting a buffer object.  Called by _mesa_HashDeleteAll().
 604  */
 605 static void
 606 delete_bufferobj_cb(GLuint id, void *data, void *userData)
 607 {
 608    struct gl_buffer_object *bufObj = (struct gl_buffer_object *) data;
 609    GLcontext *ctx = (GLcontext *) userData;
 610    ctx->Driver.DeleteBuffer(ctx, bufObj);
 611 }
 612
 613 /**
 614  * Callback for deleting an array object.  Called by _mesa_HashDeleteAll().
 615  */
 616 static void
 617 delete_arrayobj_cb(GLuint id, void *data, void *userData)
 618 {
 619    struct gl_array_object *arrayObj = (struct gl_array_object *) data;
 620    GLcontext *ctx = (GLcontext *) userData;
 621    _mesa_delete_array_object(ctx, arrayObj);
 622 }
 623
 624 /**
 625  * Callback for freeing shader program data. Call it before delete_shader_cb
 626  * to avoid memory access error.
 627  */
 628 static void
 629 free_shader_program_data_cb(GLuint id, void *data, void *userData)
 630 {
 631    GLcontext *ctx = (GLcontext *) userData;
 632    struct gl_shader_program *shProg = (struct gl_shader_program *) data;
 633
 634    if (shProg->Type == GL_SHADER_PROGRAM_MESA) {
 635        _mesa_free_shader_program_data(ctx, shProg);
 636    }
 637 }
 638
 639 /**
 640  * Callback for deleting shader and shader programs objects.
 641  * Called by _mesa_HashDeleteAll().
 642  */
 643 static void
 644 delete_shader_cb(GLuint id, void *data, void *userData)
 645 {
 646    GLcontext *ctx = (GLcontext *) userData;
 647    struct gl_shader *sh = (struct gl_shader *) data;
 648    if (sh->Type == GL_FRAGMENT_SHADER || sh->Type == GL_VERTEX_SHADER) {
 649       _mesa_free_shader(ctx, sh);
 650    }
 651    else {
 652       struct gl_shader_program *shProg = (struct gl_shader_program *) data;
 653       ASSERT(shProg->Type == GL_SHADER_PROGRAM_MESA);
 654       _mesa_free_shader_program(ctx, shProg);
 655    }
 656 }
 657
 658 /**
 659  * Callback for deleting a framebuffer object.  Called by _mesa_HashDeleteAll()
 660  */
 661 static void
 662 delete_framebuffer_cb(GLuint id, void *data, void *userData)
 663 {
 664    struct gl_framebuffer *fb = (struct gl_framebuffer *) data;
 665    /* The fact that the framebuffer is in the hashtable means its refcount
 666     * is one, but we're removing from the hashtable now.  So clear refcount.
 667     */
 668    /*assert(fb->RefCount == 1);*/
 669    fb->RefCount = 0;
 670
 671    /* NOTE: Delete should always be defined but there are two reports
 672     * of it being NULL (bugs 13507, 14293).  Work-around for now.
 673     */
 674    if (fb->Delete)
 675       fb->Delete(fb);
 676 }
 677
 678 /**
 679  * Callback for deleting a renderbuffer object. Called by _mesa_HashDeleteAll()
 680  */
 681 static void
 682 delete_renderbuffer_cb(GLuint id, void *data, void *userData)
 683 {
 684    struct gl_renderbuffer *rb = (struct gl_renderbuffer *) data;
 685    rb->RefCount = 0;  /* see comment for FBOs above */
 686    rb->Delete(rb);
 687 }
 688
 689
 690
 691 /**
 692  * Deallocate a shared state object and all children structures.
 693  *
 694  * \param ctx GL context.
 695  * \param ss shared state pointer.
 696  *
 697  * Frees the display lists, the texture objects (calling the driver texture
 698  * deletion callback to free its private data) and the vertex programs, as well
 699  * as their hash tables.
 700  *
 701  * \sa alloc_shared_state().
 702  */
 703 static void
 704 free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
 705 {
 706    /*
 707     * Free display lists
 708     */
 709    _mesa_HashDeleteAll(ss->DisplayList, delete_displaylist_cb, ctx);
 710    _mesa_DeleteHashTable(ss->DisplayList);
 711
 712 #if defined(FEATURE_NV_vertex_program) || defined(FEATURE_NV_fragment_program)
 713    _mesa_HashDeleteAll(ss->Programs, delete_program_cb, ctx);
 714    _mesa_DeleteHashTable(ss->Programs);
 715 #endif
 716 #if FEATURE_ARB_vertex_program
 717    ctx->Driver.DeleteProgram(ctx, ss->DefaultVertexProgram);
 718 #endif
 719 #if FEATURE_ARB_fragment_program
 720    ctx->Driver.DeleteProgram(ctx, ss->DefaultFragmentProgram);
 721 #endif
 722
 723 #if FEATURE_ATI_fragment_shader
 724    _mesa_HashDeleteAll(ss->ATIShaders, delete_fragshader_cb, ctx);
 725    _mesa_DeleteHashTable(ss->ATIShaders);
 726    _mesa_delete_ati_fragment_shader(ctx, ss->DefaultFragmentShader);
 727 #endif
 728
 729 #if FEATURE_ARB_vertex_buffer_object || FEATURE_ARB_pixel_buffer_object
 730    _mesa_HashDeleteAll(ss->BufferObjects, delete_bufferobj_cb, ctx);
 731    _mesa_DeleteHashTable(ss->BufferObjects);
 732 #endif
 733
 734    _mesa_HashDeleteAll(ss->ArrayObjects, delete_arrayobj_cb, ctx);
 735    _mesa_DeleteHashTable(ss->ArrayObjects);
 736
 737 #if FEATURE_ARB_shader_objects
 738    _mesa_HashWalk(ss->ShaderObjects, free_shader_program_data_cb, ctx);
 739    _mesa_HashDeleteAll(ss->ShaderObjects, delete_shader_cb, ctx);
 740    _mesa_DeleteHashTable(ss->ShaderObjects);
 741 #endif
 742
 743 #if FEATURE_EXT_framebuffer_object
 744    _mesa_HashDeleteAll(ss->FrameBuffers, delete_framebuffer_cb, ctx);
 745    _mesa_DeleteHashTable(ss->FrameBuffers);
 746    _mesa_HashDeleteAll(ss->RenderBuffers, delete_renderbuffer_cb, ctx);
 747    _mesa_DeleteHashTable(ss->RenderBuffers);
 748 #endif
 749
 750    /*
 751     * Free texture objects (after FBOs since some textures might have
 752     * been bound to FBOs).
 753     */
 754    ASSERT(ctx->Driver.DeleteTexture);
 755    /* the default textures */
 756    ctx->Driver.DeleteTexture(ctx, ss->Default1D);
 757    ctx->Driver.DeleteTexture(ctx, ss->Default2D);
 758    ctx->Driver.DeleteTexture(ctx, ss->Default3D);
 759    ctx->Driver.DeleteTexture(ctx, ss->DefaultCubeMap);
 760    ctx->Driver.DeleteTexture(ctx, ss->DefaultRect);
 761    ctx->Driver.DeleteTexture(ctx, ss->Default1DArray);
 762    ctx->Driver.DeleteTexture(ctx, ss->Default2DArray);
 763    /* all other textures */
 764    _mesa_HashDeleteAll(ss->TexObjects, delete_texture_cb, ctx);
 765    _mesa_DeleteHashTable(ss->TexObjects);
 766
 767    _glthread_DESTROY_MUTEX(ss->Mutex);
 768
 769    _mesa_free(ss);
 770 }
 771
 772
 773 /**
 774  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
 775  */
 776 static void
 777 _mesa_init_current(GLcontext *ctx)
 778 {
 779    GLuint i;
 780
 781    /* Init all to (0,0,0,1) */
 782    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 783       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
 784    }
 785
 786    /* redo special cases: */
 787    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
 788    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
 789    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
 790    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
 791    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
 792    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
 793 }
 794
 795
 796 /**
 797  * Init vertex/fragment program native limits from logical limits.
 798  */
 799 static void
 800 init_natives(struct gl_program_constants *prog)
 801 {
 802    prog->MaxNativeInstructions = prog->MaxInstructions;
 803    prog->MaxNativeAluInstructions = prog->MaxAluInstructions;
 804    prog->MaxNativeTexInstructions = prog->MaxTexInstructions;
 805    prog->MaxNativeTexIndirections = prog->MaxTexIndirections;
 806    prog->MaxNativeAttribs = prog->MaxAttribs;
 807    prog->MaxNativeTemps = prog->MaxTemps;
 808    prog->MaxNativeAddressRegs = prog->MaxAddressRegs;
 809    prog->MaxNativeParameters = prog->MaxParameters;
 810 }
 811
 812
 813 /**
 814  * Initialize fields of gl_constants (aka ctx->Const.*).
 815  * Use defaults from config.h.  The device drivers will often override
 816  * some of these values (such as number of texture units).
 817  */
 818 static void
 819 _mesa_init_constants(GLcontext *ctx)
 820 {
 821    assert(ctx);
 822
 823    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
 824    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
 825
 826    assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_COORD_UNITS);
 827    assert(MAX_TEXTURE_UNITS >= MAX_TEXTURE_IMAGE_UNITS);
 828
 829    /* Constants, may be overriden (usually only reduced) by device drivers */
 830    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
 831    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
 832    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
 833    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
 834    ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
 835    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
 836    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
 837    ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
 838                                      ctx->Const.MaxTextureImageUnits);
 839    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
 840    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
 841    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
 842    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
 843    ctx->Const.MinPointSize = MIN_POINT_SIZE;
 844    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
 845    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
 846    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
 847    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
 848    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
 849    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
 850    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
 851    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
 852    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
 853    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
 854    ctx->Const.MaxConvolutionWidth = MAX_CONVOLUTION_WIDTH;
 855    ctx->Const.MaxConvolutionHeight = MAX_CONVOLUTION_HEIGHT;
 856    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
 857    ctx->Const.MaxLights = MAX_LIGHTS;
 858    ctx->Const.MaxShininess = 128.0;
 859    ctx->Const.MaxSpotExponent = 128.0;
 860    ctx->Const.MaxViewportWidth = MAX_WIDTH;
 861    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
 862 #if FEATURE_ARB_vertex_program
 863    ctx->Const.VertexProgram.MaxInstructions = MAX_NV_VERTEX_PROGRAM_INSTRUCTIONS;
 864    ctx->Const.VertexProgram.MaxAluInstructions = 0;
 865    ctx->Const.VertexProgram.MaxTexInstructions = 0;
 866    ctx->Const.VertexProgram.MaxTexIndirections = 0;
 867    ctx->Const.VertexProgram.MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
 868    ctx->Const.VertexProgram.MaxTemps = MAX_PROGRAM_TEMPS;
 869    ctx->Const.VertexProgram.MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
 870    ctx->Const.VertexProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 871    ctx->Const.VertexProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 872    ctx->Const.VertexProgram.MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
 873    ctx->Const.VertexProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
 874    init_natives(&ctx->Const.VertexProgram);
 875 #endif
 876
 877 #if FEATURE_ARB_fragment_program
 878    ctx->Const.FragmentProgram.MaxInstructions = MAX_NV_FRAGMENT_PROGRAM_INSTRUCTIONS;
 879    ctx->Const.FragmentProgram.MaxAluInstructions = MAX_FRAGMENT_PROGRAM_ALU_INSTRUCTIONS;
 880    ctx->Const.FragmentProgram.MaxTexInstructions = MAX_FRAGMENT_PROGRAM_TEX_INSTRUCTIONS;
 881    ctx->Const.FragmentProgram.MaxTexIndirections = MAX_FRAGMENT_PROGRAM_TEX_INDIRECTIONS;
 882    ctx->Const.FragmentProgram.MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
 883    ctx->Const.FragmentProgram.MaxTemps = MAX_PROGRAM_TEMPS;
 884    ctx->Const.FragmentProgram.MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
 885    ctx->Const.FragmentProgram.MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
 886    ctx->Const.FragmentProgram.MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
 887    ctx->Const.FragmentProgram.MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
 888    ctx->Const.FragmentProgram.MaxUniformComponents = 4 * MAX_UNIFORMS;
 889    init_natives(&ctx->Const.FragmentProgram);
 890 #endif
 891    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
 892    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
 893
 894    /* CheckArrayBounds is overriden by drivers/x11 for X server */
 895    ctx->Const.CheckArrayBounds = GL_FALSE;
 896
 897    /* GL_ARB_draw_buffers */
 898    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
 899
 900    /* GL_OES_read_format */
 901    ctx->Const.ColorReadFormat = GL_RGBA;
 902    ctx->Const.ColorReadType = GL_UNSIGNED_BYTE;
 903
 904 #if FEATURE_EXT_framebuffer_object
 905    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
 906    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
 907 #endif
 908
 909 #if FEATURE_ARB_vertex_shader
 910    ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
 911    ctx->Const.MaxVarying = MAX_VARYING;
 912 #endif
 913
 914    /* sanity checks */
 915    ASSERT(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
 916                                              ctx->Const.MaxTextureCoordUnits));
 917    ASSERT(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 918    ASSERT(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
 919
 920    ASSERT(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 921    ASSERT(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
 922    ASSERT(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
 923    ASSERT(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
 924 }
 925
 926
 927 /**
 928  * Do some sanity checks on the limits/constants for the given context.
 929  * Only called the first time a context is bound.
 930  */
 931 static void
 932 check_context_limits(GLcontext *ctx)
 933 {
 934    /* Many context limits/constants are limited by the size of
 935     * internal arrays.
 936     */
 937    assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
 938    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
 939    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
 940    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
 941
 942    assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
 943    assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
 944
 945    /* make sure largest texture image is <= MAX_WIDTH in size */
 946    assert((1 << (ctx->Const.MaxTextureLevels -1 )) <= MAX_WIDTH);
 947    assert((1 << (ctx->Const.MaxCubeTextureLevels -1 )) <= MAX_WIDTH);
 948    assert((1 << (ctx->Const.Max3DTextureLevels -1 )) <= MAX_WIDTH);
 949
 950    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
 951
 952    /* XXX probably add more tests */
 953 }
 954
 955
 956 /**
 957  * Initialize the attribute groups in a GL context.
 958  *
 959  * \param ctx GL context.
 960  *
 961  * Initializes all the attributes, calling the respective <tt>init*</tt>
 962  * functions for the more complex data structures.
 963  */
 964 static GLboolean
 965 init_attrib_groups(GLcontext *ctx)
 966 {
 967    assert(ctx);
 968
 969    /* Constants */
 970    _mesa_init_constants( ctx );
 971
 972    /* Extensions */
 973    _mesa_init_extensions( ctx );
 974
 975    /* Attribute Groups */
 976    _mesa_init_accum( ctx );
 977    _mesa_init_attrib( ctx );
 978    _mesa_init_buffer_objects( ctx );
 979    _mesa_init_color( ctx );
 980    _mesa_init_colortables( ctx );
 981    _mesa_init_current( ctx );
 982    _mesa_init_depth( ctx );
 983    _mesa_init_debug( ctx );
 984    _mesa_init_display_list( ctx );
 985    _mesa_init_eval( ctx );
 986    _mesa_init_feedback( ctx );
 987    _mesa_init_fog( ctx );
 988    _mesa_init_histogram( ctx );
 989    _mesa_init_hint( ctx );
 990    _mesa_init_line( ctx );
 991    _mesa_init_lighting( ctx );
 992    _mesa_init_matrix( ctx );
 993    _mesa_init_multisample( ctx );
 994    _mesa_init_pixel( ctx );
 995    _mesa_init_point( ctx );
 996    _mesa_init_polygon( ctx );
 997    _mesa_init_program( ctx );
 998    _mesa_init_query( ctx );
 999    _mesa_init_rastpos( ctx );
1000    _mesa_init_scissor( ctx );
1001    _mesa_init_shader_state( ctx );
1002    _mesa_init_stencil( ctx );
1003    _mesa_init_transform( ctx );
1004    _mesa_init_varray( ctx );
1005    _mesa_init_viewport( ctx );
1006
1007    if (!_mesa_init_texture( ctx ))
1008       return GL_FALSE;
1009
1010    _mesa_init_texture_s3tc( ctx );
1011    _mesa_init_texture_fxt1( ctx );
1012
1013    /* Miscellaneous */
1014    ctx->NewState = _NEW_ALL;
1015    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
1016
1017    return GL_TRUE;
1018 }
1019
1020
1021 /**
1022  * Update default objects in a GL context with respect to shared state.
1023  *
1024  * \param ctx GL context.
1025  *
1026  * Removes references to old default objects, (texture objects, program
1027  * objects, etc.) and changes to reference those from the current shared
1028  * state.
1029  */
1030 static GLboolean
1031 update_default_objects(GLcontext *ctx)
1032 {
1033    assert(ctx);
1034
1035    _mesa_update_default_objects_program(ctx);
1036    _mesa_update_default_objects_texture(ctx);
1037    _mesa_update_default_objects_buffer_objects(ctx);
1038
1039    return GL_TRUE;
1040 }
1041
1042
1043 /**
1044  * This is the default function we plug into all dispatch table slots
1045  * This helps prevents a segfault when someone calls a GL function without
1046  * first checking if the extension's supported.
1047  */
1048 static int
1049 generic_nop(void)
1050 {
1051    _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
1052    return 0;
1053 }
1054
1055
1056 /**
1057  * Allocate and initialize a new dispatch table.
1058  */
1059 static struct _glapi_table *
1060 alloc_dispatch_table(void)
1061 {
1062    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
1063     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
1064     * Mesa we do this to accomodate different versions of libGL and various
1065     * DRI drivers.
1066     */
1067    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(),
1068                            sizeof(struct _glapi_table) / sizeof(_glapi_proc));
1069    struct _glapi_table *table =
1070       (struct _glapi_table *) _mesa_malloc(numEntries * sizeof(_glapi_proc));
1071    if (table) {
1072       _glapi_proc *entry = (_glapi_proc *) table;
1073       GLint i;
1074       for (i = 0; i < numEntries; i++) {
1075          entry[i] = (_glapi_proc) generic_nop;
1076       }
1077    }
1078    return table;
1079 }
1080
1081
1082 /**
1083  * Initialize a GLcontext struct (rendering context).
1084  *
1085  * This includes allocating all the other structs and arrays which hang off of
1086  * the context by pointers.
1087  * Note that the driver needs to pass in its dd_function_table here since
1088  * we need to at least call driverFunctions->NewTextureObject to create the
1089  * default texture objects.
1090  *
1091  * Called by _mesa_create_context().
1092  *
1093  * Performs the imports and exports callback tables initialization, and
1094  * miscellaneous one-time initializations. If no shared context is supplied one
1095  * is allocated, and increase its reference count.  Setups the GL API dispatch
1096  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
1097  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
1098  * for debug flags.
1099  *
1100  * \param ctx the context to initialize
1101  * \param visual describes the visual attributes for this context
1102  * \param share_list points to context to share textures, display lists,
1103  *        etc with, or NULL
1104  * \param driverFunctions table of device driver functions for this context
1105  *        to use
1106  * \param driverContext pointer to driver-specific context data
1107  */
1108 GLboolean
1109 _mesa_initialize_context(GLcontext *ctx,
1110                          const GLvisual *visual,
1111                          GLcontext *share_list,
1112                          const struct dd_function_table *driverFunctions,
1113                          void *driverContext)
1114 {
1115    ASSERT(driverContext);
1116    assert(driverFunctions->NewTextureObject);
1117    assert(driverFunctions->FreeTexImageData);
1118
1119    /* misc one-time initializations */
1120    one_time_init(ctx);
1121
1122    ctx->Visual = *visual;
1123    ctx->DrawBuffer = NULL;
1124    ctx->ReadBuffer = NULL;
1125    ctx->WinSysDrawBuffer = NULL;
1126    ctx->WinSysReadBuffer = NULL;
1127
1128    /* Plug in driver functions and context pointer here.
1129     * This is important because when we call alloc_shared_state() below
1130     * we'll call ctx->Driver.NewTextureObject() to create the default
1131     * textures.
1132     */
1133    ctx->Driver = *driverFunctions;
1134    ctx->DriverCtx = driverContext;
1135
1136    if (share_list) {
1137       /* share state with another context */
1138       ctx->Shared = share_list->Shared;
1139    }
1140    else {
1141       /* allocate new, unshared state */
1142       if (!alloc_shared_state( ctx )) {
1143          return GL_FALSE;
1144       }
1145    }
1146    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1147    ctx->Shared->RefCount++;
1148    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1149
1150    if (!init_attrib_groups( ctx )) {
1151       free_shared_state(ctx, ctx->Shared);
1152       return GL_FALSE;
1153    }
1154
1155    /* setup the API dispatch tables */
1156    ctx->Exec = alloc_dispatch_table();
1157    ctx->Save = alloc_dispatch_table();
1158    if (!ctx->Exec || !ctx->Save) {
1159       free_shared_state(ctx, ctx->Shared);
1160       if (ctx->Exec)
1161          _mesa_free(ctx->Exec);
1162    }
1163    _mesa_init_exec_table(ctx->Exec);
1164    ctx->CurrentDispatch = ctx->Exec;
1165 #if _HAVE_FULL_GL
1166    _mesa_init_dlist_table(ctx->Save);
1167    _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
1168    /* Neutral tnl module stuff */
1169    _mesa_init_exec_vtxfmt( ctx );
1170    ctx->TnlModule.Current = NULL;
1171    ctx->TnlModule.SwapCount = 0;
1172 #endif
1173
1174    ctx->FragmentProgram._MaintainTexEnvProgram
1175       = (_mesa_getenv("MESA_TEX_PROG") != NULL);
1176    ctx->FragmentProgram._UseTexEnvProgram = ctx->FragmentProgram._MaintainTexEnvProgram;
1177
1178    ctx->VertexProgram._MaintainTnlProgram
1179       = (_mesa_getenv("MESA_TNL_PROG") != NULL);
1180    if (ctx->VertexProgram._MaintainTnlProgram) {
1181       /* this is required... */
1182       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
1183    }
1184
1185    ctx->FirstTimeCurrent = GL_TRUE;
1186
1187    return GL_TRUE;
1188 }
1189
1190
1191 /**
1192  * Allocate and initialize a GLcontext structure.
1193  * Note that the driver needs to pass in its dd_function_table here since
1194  * we need to at least call driverFunctions->NewTextureObject to initialize
1195  * the rendering context.
1196  *
1197  * \param visual a GLvisual pointer (we copy the struct contents)
1198  * \param share_list another context to share display lists with or NULL
1199  * \param driverFunctions points to the dd_function_table into which the
1200  *        driver has plugged in all its special functions.
1201  * \param driverCtx points to the device driver's private context state
1202  *
1203  * \return pointer to a new __GLcontextRec or NULL if error.
1204  */
1205 GLcontext *
1206 _mesa_create_context(const GLvisual *visual,
1207                      GLcontext *share_list,
1208                      const struct dd_function_table *driverFunctions,
1209                      void *driverContext)
1210 {
1211    GLcontext *ctx;
1212
1213    ASSERT(visual);
1214    ASSERT(driverContext);
1215
1216    ctx = (GLcontext *) _mesa_calloc(sizeof(GLcontext));
1217    if (!ctx)
1218       return NULL;
1219
1220    if (_mesa_initialize_context(ctx, visual, share_list,
1221                                 driverFunctions, driverContext)) {
1222       return ctx;
1223    }
1224    else {
1225       _mesa_free(ctx);
1226       return NULL;
1227    }
1228 }
1229
1230
1231 /**
1232  * Free the data associated with the given context.
1233  *
1234  * But doesn't free the GLcontext struct itself.
1235  *
1236  * \sa _mesa_initialize_context() and init_attrib_groups().
1237  */
1238 void
1239 _mesa_free_context_data( GLcontext *ctx )
1240 {
1241    if (!_mesa_get_current_context()){
1242       /* No current context, but we may need one in order to delete
1243        * texture objs, etc.  So temporarily bind the context now.
1244        */
1245       _mesa_make_current(ctx, NULL, NULL);
1246    }
1247
1248    /* unreference WinSysDraw/Read buffers */
1249    _mesa_unreference_framebuffer(&ctx->WinSysDrawBuffer);
1250    _mesa_unreference_framebuffer(&ctx->WinSysReadBuffer);
1251    _mesa_unreference_framebuffer(&ctx->DrawBuffer);
1252    _mesa_unreference_framebuffer(&ctx->ReadBuffer);
1253
1254    _mesa_free_attrib_data(ctx);
1255    _mesa_free_lighting_data( ctx );
1256    _mesa_free_eval_data( ctx );
1257    _mesa_free_texture_data( ctx );
1258    _mesa_free_matrix_data( ctx );
1259    _mesa_free_viewport_data( ctx );
1260    _mesa_free_colortables_data( ctx );
1261    _mesa_free_program_data(ctx);
1262    _mesa_free_shader_state(ctx);
1263    _mesa_free_query_data(ctx);
1264
1265 #if FEATURE_ARB_vertex_buffer_object
1266    _mesa_delete_buffer_object(ctx, ctx->Array.NullBufferObj);
1267 #endif
1268    _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
1269
1270    /* free dispatch tables */
1271    _mesa_free(ctx->Exec);
1272    _mesa_free(ctx->Save);
1273
1274    /* Shared context state (display lists, textures, etc) */
1275    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
1276    ctx->Shared->RefCount--;
1277    assert(ctx->Shared->RefCount >= 0);
1278    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
1279    if (ctx->Shared->RefCount == 0) {
1280       /* free shared state */
1281       free_shared_state( ctx, ctx->Shared );
1282    }
1283
1284    if (ctx->Extensions.String)
1285       _mesa_free((void *) ctx->Extensions.String);
1286
1287    /* unbind the context if it's currently bound */
1288    if (ctx == _mesa_get_current_context()) {
1289       _mesa_make_current(NULL, NULL, NULL);
1290    }
1291 }
1292
1293
1294 /**
1295  * Destroy a GLcontext structure.
1296  *
1297  * \param ctx GL context.
1298  *
1299  * Calls _mesa_free_context_data() and frees the GLcontext structure itself.
1300  */
1301 void
1302 _mesa_destroy_context( GLcontext *ctx )
1303 {
1304    if (ctx) {
1305       _mesa_free_context_data(ctx);
1306       _mesa_free( (void *) ctx );
1307    }
1308 }
1309
1310
1311 #if _HAVE_FULL_GL
1312 /**
1313  * Copy attribute groups from one context to another.
1314  *
1315  * \param src source context
1316  * \param dst destination context
1317  * \param mask bitwise OR of GL_*_BIT flags
1318  *
1319  * According to the bits specified in \p mask, copies the corresponding
1320  * attributes from \p src into \p dst.  For many of the attributes a simple \c
1321  * memcpy is not enough due to the existence of internal pointers in their data
1322  * structures.
1323  */
1324 void
1325 _mesa_copy_context( const GLcontext *src, GLcontext *dst, GLuint mask )
1326 {
1327    if (mask & GL_ACCUM_BUFFER_BIT) {
1328       /* OK to memcpy */
1329       dst->Accum = src->Accum;
1330    }
1331    if (mask & GL_COLOR_BUFFER_BIT) {
1332       /* OK to memcpy */
1333       dst->Color = src->Color;
1334    }
1335    if (mask & GL_CURRENT_BIT) {
1336       /* OK to memcpy */
1337       dst->Current = src->Current;
1338    }
1339    if (mask & GL_DEPTH_BUFFER_BIT) {
1340       /* OK to memcpy */
1341       dst->Depth = src->Depth;
1342    }
1343    if (mask & GL_ENABLE_BIT) {
1344       /* no op */
1345    }
1346    if (mask & GL_EVAL_BIT) {
1347       /* OK to memcpy */
1348       dst->Eval = src->Eval;
1349    }
1350    if (mask & GL_FOG_BIT) {
1351       /* OK to memcpy */
1352       dst->Fog = src->Fog;
1353    }
1354    if (mask & GL_HINT_BIT) {
1355       /* OK to memcpy */
1356       dst->Hint = src->Hint;
1357    }
1358    if (mask & GL_LIGHTING_BIT) {
1359       GLuint i;
1360       /* begin with memcpy */
1361       dst->Light = src->Light;
1362       /* fixup linked lists to prevent pointer insanity */
1363       make_empty_list( &(dst->Light.EnabledList) );
1364       for (i = 0; i < MAX_LIGHTS; i++) {
1365          if (dst->Light.Light[i].Enabled) {
1366             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
1367          }
1368       }
1369    }
1370    if (mask & GL_LINE_BIT) {
1371       /* OK to memcpy */
1372       dst->Line = src->Line;
1373    }
1374    if (mask & GL_LIST_BIT) {
1375       /* OK to memcpy */
1376       dst->List = src->List;
1377    }
1378    if (mask & GL_PIXEL_MODE_BIT) {
1379       /* OK to memcpy */
1380       dst->Pixel = src->Pixel;
1381    }
1382    if (mask & GL_POINT_BIT) {
1383       /* OK to memcpy */
1384       dst->Point = src->Point;
1385    }
1386    if (mask & GL_POLYGON_BIT) {
1387       /* OK to memcpy */
1388       dst->Polygon = src->Polygon;
1389    }
1390    if (mask & GL_POLYGON_STIPPLE_BIT) {
1391       /* Use loop instead of MEMCPY due to problem with Portland Group's
1392        * C compiler.  Reported by John Stone.
1393        */
1394       GLuint i;
1395       for (i = 0; i < 32; i++) {
1396          dst->PolygonStipple[i] = src->PolygonStipple[i];
1397       }
1398    }
1399    if (mask & GL_SCISSOR_BIT) {
1400       /* OK to memcpy */
1401       dst->Scissor = src->Scissor;
1402    }
1403    if (mask & GL_STENCIL_BUFFER_BIT) {
1404       /* OK to memcpy */
1405       dst->Stencil = src->Stencil;
1406    }
1407    if (mask & GL_TEXTURE_BIT) {
1408       /* Cannot memcpy because of pointers */
1409       _mesa_copy_texture_state(src, dst);
1410    }
1411    if (mask & GL_TRANSFORM_BIT) {
1412       /* OK to memcpy */
1413       dst->Transform = src->Transform;
1414    }
1415    if (mask & GL_VIEWPORT_BIT) {
1416       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
1417       dst->Viewport.X = src->Viewport.X;
1418       dst->Viewport.Y = src->Viewport.Y;
1419       dst->Viewport.Width = src->Viewport.Width;
1420       dst->Viewport.Height = src->Viewport.Height;
1421       dst->Viewport.Near = src->Viewport.Near;
1422       dst->Viewport.Far = src->Viewport.Far;
1423       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
1424    }
1425
1426    /* XXX FIXME:  Call callbacks?
1427     */
1428    dst->NewState = _NEW_ALL;
1429 }
1430 #endif
1431
1432
1433 /**
1434  * Check if the given context can render into the given framebuffer
1435  * by checking visual attributes.
1436  *
1437  * Most of these tests could go away because Mesa is now pretty flexible
1438  * in terms of mixing rendering contexts with framebuffers.  As long
1439  * as RGB vs. CI mode agree, we're probably good.
1440  *
1441  * \return GL_TRUE if compatible, GL_FALSE otherwise.
1442  */
1443 static GLboolean
1444 check_compatible(const GLcontext *ctx, const GLframebuffer *buffer)
1445 {
1446    const GLvisual *ctxvis = &ctx->Visual;
1447    const GLvisual *bufvis = &buffer->Visual;
1448
1449    if (ctxvis == bufvis)
1450       return GL_TRUE;
1451
1452    if (ctxvis->rgbMode != bufvis->rgbMode)
1453       return GL_FALSE;
1454 #if 0
1455    /* disabling this fixes the fgl_glxgears pbuffer demo */
1456    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
1457       return GL_FALSE;
1458 #endif
1459    if (ctxvis->stereoMode && !bufvis->stereoMode)
1460       return GL_FALSE;
1461    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
1462       return GL_FALSE;
1463    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
1464       return GL_FALSE;
1465    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
1466       return GL_FALSE;
1467    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
1468       return GL_FALSE;
1469    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
1470       return GL_FALSE;
1471    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
1472       return GL_FALSE;
1473 #if 0
1474    /* disabled (see bug 11161) */
1475    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
1476       return GL_FALSE;
1477 #endif
1478    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
1479       return GL_FALSE;
1480
1481    return GL_TRUE;
1482 }
1483
1484
1485 /**
1486  * Do one-time initialization for the given framebuffer.  Specifically,
1487  * ask the driver for the window's current size and update the framebuffer
1488  * object to match.
1489  * Really, the device driver should totally take care of this.
1490  */
1491 static void
1492 initialize_framebuffer_size(GLcontext *ctx, GLframebuffer *fb)
1493 {
1494    GLuint width, height;
1495    if (ctx->Driver.GetBufferSize) {
1496       ctx->Driver.GetBufferSize(fb, &width, &height);
1497       if (ctx->Driver.ResizeBuffers)
1498          ctx->Driver.ResizeBuffers(ctx, fb, width, height);
1499       fb->Initialized = GL_TRUE;
1500    }
1501 }
1502
1503
1504 /**
1505  * Bind the given context to the given drawBuffer and readBuffer and
1506  * make it the current context for the calling thread.
1507  * We'll render into the drawBuffer and read pixels from the
1508  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
1509  *
1510  * We check that the context's and framebuffer's visuals are compatible
1511  * and return immediately if they're not.
1512  *
1513  * \param newCtx  the new GL context. If NULL then there will be no current GL
1514  *                context.
1515  * \param drawBuffer  the drawing framebuffer
1516  * \param readBuffer  the reading framebuffer
1517  */
1518 void
1519 _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
1520                     GLframebuffer *readBuffer )
1521 {
1522    if (MESA_VERBOSE & VERBOSE_API)
1523       _mesa_debug(newCtx, "_mesa_make_current()\n");
1524
1525    /* Check that the context's and framebuffer's visuals are compatible.
1526     */
1527    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
1528       if (!check_compatible(newCtx, drawBuffer)) {
1529          _mesa_warning(newCtx,
1530               "MakeCurrent: incompatible visuals for context and drawbuffer");
1531          return;
1532       }
1533    }
1534    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
1535       if (!check_compatible(newCtx, readBuffer)) {
1536          _mesa_warning(newCtx,
1537               "MakeCurrent: incompatible visuals for context and readbuffer");
1538          return;
1539       }
1540    }
1541
1542    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
1543    _glapi_set_context((void *) newCtx);
1544    ASSERT(_mesa_get_current_context() == newCtx);
1545
1546    if (!newCtx) {
1547       _glapi_set_dispatch(NULL);  /* none current */
1548    }
1549    else {
1550       _glapi_set_dispatch(newCtx->CurrentDispatch);
1551
1552       if (drawBuffer && readBuffer) {
1553          /* TODO: check if newCtx and buffer's visual match??? */
1554
1555          ASSERT(drawBuffer->Name == 0);
1556          ASSERT(readBuffer->Name == 0);
1557          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
1558          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
1559
1560          /*
1561           * Only set the context's Draw/ReadBuffer fields if they're NULL
1562           * or not bound to a user-created FBO.
1563           */
1564          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
1565             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
1566          }
1567          if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
1568             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
1569          }
1570
1571          /* XXX only set this flag if we're really changing the draw/read
1572           * framebuffer bindings.
1573           */
1574          newCtx->NewState |= _NEW_BUFFERS;
1575
1576 #if 1
1577          /* We want to get rid of these lines: */
1578
1579 #if _HAVE_FULL_GL
1580          if (!drawBuffer->Initialized) {
1581             initialize_framebuffer_size(newCtx, drawBuffer);
1582          }
1583          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
1584             initialize_framebuffer_size(newCtx, readBuffer);
1585          }
1586
1587          _mesa_resizebuffers(newCtx);
1588 #endif
1589
1590 #else
1591          /* We want the drawBuffer and readBuffer to be initialized by
1592           * the driver.
1593           * This generally means the Width and Height match the actual
1594           * window size and the renderbuffers (both hardware and software
1595           * based) are allocated to match.  The later can generally be
1596           * done with a call to _mesa_resize_framebuffer().
1597           *
1598           * It's theoretically possible for a buffer to have zero width
1599           * or height, but for now, assert check that the driver did what's
1600           * expected of it.
1601           */
1602          ASSERT(drawBuffer->Width > 0);
1603          ASSERT(drawBuffer->Height > 0);
1604 #endif
1605
1606          if (newCtx->FirstTimeCurrent) {
1607             /* set initial viewport and scissor size now */
1608             _mesa_set_viewport(newCtx, 0, 0,
1609                                drawBuffer->Width, drawBuffer->Height);
1610             _mesa_set_scissor(newCtx, 0, 0,
1611                               drawBuffer->Width, drawBuffer->Height );
1612             check_context_limits(newCtx);
1613          }
1614       }
1615
1616       /* We can use this to help debug user's problems.  Tell them to set
1617        * the MESA_INFO env variable before running their app.  Then the
1618        * first time each context is made current we'll print some useful
1619        * information.
1620        */
1621       if (newCtx->FirstTimeCurrent) {
1622          if (_mesa_getenv("MESA_INFO")) {
1623             _mesa_print_info();
1624          }
1625          newCtx->FirstTimeCurrent = GL_FALSE;
1626       }
1627    }
1628 }
1629
1630
1631 /**
1632  * Make context 'ctx' share the display lists, textures and programs
1633  * that are associated with 'ctxToShare'.
1634  * Any display lists, textures or programs associated with 'ctx' will
1635  * be deleted if nobody else is sharing them.
1636  */
1637 GLboolean
1638 _mesa_share_state(GLcontext *ctx, GLcontext *ctxToShare)
1639 {
1640    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
1641       struct gl_shared_state *oldSharedState = ctx->Shared;
1642
1643       ctx->Shared = ctxToShare->Shared;
1644       ctx->Shared->RefCount++;
1645
1646       update_default_objects(ctx);
1647
1648       oldSharedState->RefCount--;
1649       if (oldSharedState->RefCount == 0) {
1650          free_shared_state(ctx, oldSharedState);
1651       }
1652
1653       return GL_TRUE;
1654    }
1655    else {
1656       return GL_FALSE;
1657    }
1658 }
1659
1660
1661
1662 /**
1663  * \return pointer to the current GL context for this thread.
1664  *
1665  * Calls _glapi_get_context(). This isn't the fastest way to get the current
1666  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
1667  * context.h.
1668  */
1669 GLcontext *
1670 _mesa_get_current_context( void )
1671 {
1672    return (GLcontext *) _glapi_get_context();
1673 }
1674
1675
1676 /**
1677  * Get context's current API dispatch table.
1678  *
1679  * It'll either be the immediate-mode execute dispatcher or the display list
1680  * compile dispatcher.
1681  *
1682  * \param ctx GL context.
1683  *
1684  * \return pointer to dispatch_table.
1685  *
1686  * Simply returns __GLcontextRec::CurrentDispatch.
1687  */
1688 struct _glapi_table *
1689 _mesa_get_dispatch(GLcontext *ctx)
1690 {
1691    return ctx->CurrentDispatch;
1692 }
1693
1694 /*@}*/
1695
1696
1697 /**********************************************************************/
1698 /** \name Miscellaneous functions                                     */
1699 /**********************************************************************/
1700 /*@{*/
1701
1702 /**
1703  * Record an error.
1704  *
1705  * \param ctx GL context.
1706  * \param error error code.
1707  *
1708  * Records the given error code and call the driver's dd_function_table::Error
1709  * function if defined.
1710  *
1711  * \sa
1712  * This is called via _mesa_error().
1713  */
1714 void
1715 _mesa_record_error(GLcontext *ctx, GLenum error)
1716 {
1717    if (!ctx)
1718       return;
1719
1720    if (ctx->ErrorValue == GL_NO_ERROR) {
1721       ctx->ErrorValue = error;
1722    }
1723
1724    /* Call device driver's error handler, if any.  This is used on the Mac. */
1725    if (ctx->Driver.Error) {
1726       ctx->Driver.Error(ctx);
1727    }
1728 }
1729
1730
1731 /**
1732  * Execute glFinish().
1733  *
1734  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1735  * dd_function_table::Finish driver callback, if not NULL.
1736  */
1737 void GLAPIENTRY
1738 _mesa_Finish(void)
1739 {
1740    GET_CURRENT_CONTEXT(ctx);
1741    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1742    if (ctx->Driver.Finish) {
1743       ctx->Driver.Finish(ctx);
1744    }
1745 }
1746
1747
1748 /**
1749  * Execute glFlush().
1750  *
1751  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
1752  * dd_function_table::Flush driver callback, if not NULL.
1753  */
1754 void GLAPIENTRY
1755 _mesa_Flush(void)
1756 {
1757    GET_CURRENT_CONTEXT(ctx);
1758    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
1759    if (ctx->Driver.Flush) {
1760       ctx->Driver.Flush(ctx);
1761    }
1762 }
1763
1764
1765 /*@}*/