src/mesa/drivers/common/meta.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.6
   4  *
   5  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /**
  26  * Meta operations.  Some GL operations can be expressed in terms of
  27  * other GL operations.  For example, glBlitFramebuffer() can be done
  28  * with texture mapping and glClear() can be done with polygon rendering.
  29  *
  30  * \author Brian Paul
  31  */
  32
  33
  34 #include "main/glheader.h"
  35 #include "main/mtypes.h"
  36 #include "main/imports.h"
  37 #include "main/arbprogram.h"
  38 #include "main/arrayobj.h"
  39 #include "main/blend.h"
  40 #include "main/bufferobj.h"
  41 #include "main/buffers.h"
  42 #include "main/colortab.h"
  43 #include "main/condrender.h"
  44 #include "main/depth.h"
  45 #include "main/enable.h"
  46 #include "main/fbobject.h"
  47 #include "main/formats.h"
  48 #include "main/image.h"
  49 #include "main/macros.h"
  50 #include "main/matrix.h"
  51 #include "main/mipmap.h"
  52 #include "main/pbo.h"
  53 #include "main/polygon.h"
  54 #include "main/readpix.h"
  55 #include "main/scissor.h"
  56 #include "main/shaderapi.h"
  57 #include "main/shaderobj.h"
  58 #include "main/state.h"
  59 #include "main/stencil.h"
  60 #include "main/texobj.h"
  61 #include "main/texenv.h"
  62 #include "main/teximage.h"
  63 #include "main/texparam.h"
  64 #include "main/texstate.h"
  65 #include "main/uniforms.h"
  66 #include "main/varray.h"
  67 #include "main/viewport.h"
  68 #include "program/program.h"
  69 #include "swrast/swrast.h"
  70 #include "drivers/common/meta.h"
  71
  72
  73 /** Return offset in bytes of the field within a vertex struct */
  74 #define OFFSET(FIELD) ((void *) offsetof(struct vertex, FIELD))
  75
  76 /**
  77  * State which we may save/restore across meta ops.
  78  * XXX this may be incomplete...
  79  */
  80 struct save_state
  81 {
  82    GLbitfield SavedState;  /**< bitmask of MESA_META_* flags */
  83
  84    /** MESA_META_ALPHA_TEST */
  85    GLboolean AlphaEnabled;
  86    GLenum AlphaFunc;
  87    GLclampf AlphaRef;
  88
  89    /** MESA_META_BLEND */
  90    GLbitfield BlendEnabled;
  91    GLboolean ColorLogicOpEnabled;
  92
  93    /** MESA_META_COLOR_MASK */
  94    GLubyte ColorMask[MAX_DRAW_BUFFERS][4];
  95
  96    /** MESA_META_DEPTH_TEST */
  97    struct gl_depthbuffer_attrib Depth;
  98
  99    /** MESA_META_FOG */
 100    GLboolean Fog;
 101
 102    /** MESA_META_PIXEL_STORE */
 103    struct gl_pixelstore_attrib Pack, Unpack;
 104
 105    /** MESA_META_PIXEL_TRANSFER */
 106    GLfloat RedBias, RedScale;
 107    GLfloat GreenBias, GreenScale;
 108    GLfloat BlueBias, BlueScale;
 109    GLfloat AlphaBias, AlphaScale;
 110    GLfloat DepthBias, DepthScale;
 111    GLboolean MapColorFlag;
 112
 113    /** MESA_META_RASTERIZATION */
 114    GLenum FrontPolygonMode, BackPolygonMode;
 115    GLboolean PolygonOffset;
 116    GLboolean PolygonSmooth;
 117    GLboolean PolygonStipple;
 118    GLboolean PolygonCull;
 119
 120    /** MESA_META_SCISSOR */
 121    struct gl_scissor_attrib Scissor;
 122
 123    /** MESA_META_SHADER */
 124    GLboolean VertexProgramEnabled;
 125    struct gl_vertex_program *VertexProgram;
 126    GLboolean FragmentProgramEnabled;
 127    struct gl_fragment_program *FragmentProgram;
 128    struct gl_shader_program *VertexShader;
 129    struct gl_shader_program *GeometryShader;
 130    struct gl_shader_program *FragmentShader;
 131    struct gl_shader_program *ActiveShader;
 132
 133    /** MESA_META_STENCIL_TEST */
 134    struct gl_stencil_attrib Stencil;
 135
 136    /** MESA_META_TRANSFORM */
 137    GLenum MatrixMode;
 138    GLfloat ModelviewMatrix[16];
 139    GLfloat ProjectionMatrix[16];
 140    GLfloat TextureMatrix[16];
 141
 142    /** MESA_META_CLIP */
 143    GLbitfield ClipPlanesEnabled;
 144
 145    /** MESA_META_TEXTURE */
 146    GLuint ActiveUnit;
 147    GLuint ClientActiveUnit;
 148    /** for unit[0] only */
 149    struct gl_texture_object *CurrentTexture[NUM_TEXTURE_TARGETS];
 150    /** mask of TEXTURE_2D_BIT, etc */
 151    GLbitfield TexEnabled[MAX_TEXTURE_UNITS];
 152    GLbitfield TexGenEnabled[MAX_TEXTURE_UNITS];
 153    GLuint EnvMode;  /* unit[0] only */
 154
 155    /** MESA_META_VERTEX */
 156    struct gl_array_object *ArrayObj;
 157    struct gl_buffer_object *ArrayBufferObj;
 158
 159    /** MESA_META_VIEWPORT */
 160    GLint ViewportX, ViewportY, ViewportW, ViewportH;
 161    GLclampd DepthNear, DepthFar;
 162
 163    /** MESA_META_CLAMP_FRAGMENT_COLOR */
 164    GLenum ClampFragmentColor;
 165
 166    /** MESA_META_CLAMP_VERTEX_COLOR */
 167    GLenum ClampVertexColor;
 168
 169    /** MESA_META_CONDITIONAL_RENDER */
 170    struct gl_query_object *CondRenderQuery;
 171    GLenum CondRenderMode;
 172
 173    /** Miscellaneous (always disabled) */
 174    GLboolean Lighting;
 175 };
 176
 177
 178 /**
 179  * Temporary texture used for glBlitFramebuffer, glDrawPixels, etc.
 180  * This is currently shared by all the meta ops.  But we could create a
 181  * separate one for each of glDrawPixel, glBlitFramebuffer, glCopyPixels, etc.
 182  */
 183 struct temp_texture
 184 {
 185    GLuint TexObj;
 186    GLenum Target;         /**< GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE */
 187    GLsizei MinSize;       /**< Min texture size to allocate */
 188    GLsizei MaxSize;       /**< Max possible texture size */
 189    GLboolean NPOT;        /**< Non-power of two size OK? */
 190    GLsizei Width, Height; /**< Current texture size */
 191    GLenum IntFormat;
 192    GLfloat Sright, Ttop;  /**< right, top texcoords */
 193 };
 194
 195
 196 /**
 197  * State for glBlitFramebufer()
 198  */
 199 struct blit_state
 200 {
 201    GLuint ArrayObj;
 202    GLuint VBO;
 203    GLuint DepthFP;
 204 };
 205
 206
 207 /**
 208  * State for glClear()
 209  */
 210 struct clear_state
 211 {
 212    GLuint ArrayObj;
 213    GLuint VBO;
 214    GLuint ShaderProg;
 215    GLint ColorLocation;
 216 };
 217
 218
 219 /**
 220  * State for glCopyPixels()
 221  */
 222 struct copypix_state
 223 {
 224    GLuint ArrayObj;
 225    GLuint VBO;
 226 };
 227
 228
 229 /**
 230  * State for glDrawPixels()
 231  */
 232 struct drawpix_state
 233 {
 234    GLuint ArrayObj;
 235
 236    GLuint StencilFP;  /**< Fragment program for drawing stencil images */
 237    GLuint DepthFP;  /**< Fragment program for drawing depth images */
 238 };
 239
 240
 241 /**
 242  * State for glBitmap()
 243  */
 244 struct bitmap_state
 245 {
 246    GLuint ArrayObj;
 247    GLuint VBO;
 248    struct temp_texture Tex;  /**< separate texture from other meta ops */
 249 };
 250
 251
 252 /**
 253  * State for _mesa_meta_generate_mipmap()
 254  */
 255 struct gen_mipmap_state
 256 {
 257    GLuint ArrayObj;
 258    GLuint VBO;
 259    GLuint FBO;
 260 };
 261
 262 #define MAX_META_OPS_DEPTH      2
 263 /**
 264  * All per-context meta state.
 265  */
 266 struct gl_meta_state
 267 {
 268    /** Stack of state saved during meta-ops */
 269    struct save_state Save[MAX_META_OPS_DEPTH];
 270    /** Save stack depth */
 271    GLuint SaveStackDepth;
 272
 273    struct temp_texture TempTex;
 274
 275    struct blit_state Blit;    /**< For _mesa_meta_BlitFramebuffer() */
 276    struct clear_state Clear;  /**< For _mesa_meta_Clear() */
 277    struct copypix_state CopyPix;  /**< For _mesa_meta_CopyPixels() */
 278    struct drawpix_state DrawPix;  /**< For _mesa_meta_DrawPixels() */
 279    struct bitmap_state Bitmap;    /**< For _mesa_meta_Bitmap() */
 280    struct gen_mipmap_state Mipmap;    /**< For _mesa_meta_GenerateMipmap() */
 281 };
 282
 283
 284 /**
 285  * Initialize meta-ops for a context.
 286  * To be called once during context creation.
 287  */
 288 void
 289 _mesa_meta_init(struct gl_context *ctx)
 290 {
 291    ASSERT(!ctx->Meta);
 292
 293    ctx->Meta = CALLOC_STRUCT(gl_meta_state);
 294 }
 295
 296
 297 /**
 298  * Free context meta-op state.
 299  * To be called once during context destruction.
 300  */
 301 void
 302 _mesa_meta_free(struct gl_context *ctx)
 303 {
 304    /* Note: Any textures, VBOs, etc, that we allocate should get
 305     * freed by the normal context destruction code.  But this would be
 306     * the place to free other meta data someday.
 307     */
 308    free(ctx->Meta);
 309    ctx->Meta = NULL;
 310 }
 311
 312
 313 /**
 314  * Enter meta state.  This is like a light-weight version of glPushAttrib
 315  * but it also resets most GL state back to default values.
 316  *
 317  * \param state  bitmask of MESA_META_* flags indicating which attribute groups
 318  *               to save and reset to their defaults
 319  */
 320 void
 321 _mesa_meta_begin(struct gl_context *ctx, GLbitfield state)
 322 {
 323    struct save_state *save;
 324
 325    /* hope MAX_META_OPS_DEPTH is large enough */
 326    assert(ctx->Meta->SaveStackDepth < MAX_META_OPS_DEPTH);
 327
 328    save = &ctx->Meta->Save[ctx->Meta->SaveStackDepth++];
 329    memset(save, 0, sizeof(*save));
 330    save->SavedState = state;
 331
 332    if (state & MESA_META_ALPHA_TEST) {
 333       save->AlphaEnabled = ctx->Color.AlphaEnabled;
 334       save->AlphaFunc = ctx->Color.AlphaFunc;
 335       save->AlphaRef = ctx->Color.AlphaRef;
 336       if (ctx->Color.AlphaEnabled)
 337          _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_FALSE);
 338    }
 339
 340    if (state & MESA_META_BLEND) {
 341       save->BlendEnabled = ctx->Color.BlendEnabled;
 342       if (ctx->Color.BlendEnabled) {
 343          if (ctx->Extensions.EXT_draw_buffers2) {
 344             GLuint i;
 345             for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 346                _mesa_set_enablei(ctx, GL_BLEND, i, GL_FALSE);
 347             }
 348          }
 349          else {
 350             _mesa_set_enable(ctx, GL_BLEND, GL_FALSE);
 351          }
 352       }
 353       save->ColorLogicOpEnabled = ctx->Color.ColorLogicOpEnabled;
 354       if (ctx->Color.ColorLogicOpEnabled)
 355          _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, GL_FALSE);
 356    }
 357
 358    if (state & MESA_META_COLOR_MASK) {
 359       memcpy(save->ColorMask, ctx->Color.ColorMask,
 360              sizeof(ctx->Color.ColorMask));
 361       if (!ctx->Color.ColorMask[0][0] ||
 362           !ctx->Color.ColorMask[0][1] ||
 363           !ctx->Color.ColorMask[0][2] ||
 364           !ctx->Color.ColorMask[0][3])
 365          _mesa_ColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 366    }
 367
 368    if (state & MESA_META_DEPTH_TEST) {
 369       save->Depth = ctx->Depth; /* struct copy */
 370       if (ctx->Depth.Test)
 371          _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_FALSE);
 372    }
 373
 374    if (state & MESA_META_FOG) {
 375       save->Fog = ctx->Fog.Enabled;
 376       if (ctx->Fog.Enabled)
 377          _mesa_set_enable(ctx, GL_FOG, GL_FALSE);
 378    }
 379
 380    if (state & MESA_META_PIXEL_STORE) {
 381       save->Pack = ctx->Pack;
 382       save->Unpack = ctx->Unpack;
 383       ctx->Pack = ctx->DefaultPacking;
 384       ctx->Unpack = ctx->DefaultPacking;
 385    }
 386
 387    if (state & MESA_META_PIXEL_TRANSFER) {
 388       save->RedScale = ctx->Pixel.RedScale;
 389       save->RedBias = ctx->Pixel.RedBias;
 390       save->GreenScale = ctx->Pixel.GreenScale;
 391       save->GreenBias = ctx->Pixel.GreenBias;
 392       save->BlueScale = ctx->Pixel.BlueScale;
 393       save->BlueBias = ctx->Pixel.BlueBias;
 394       save->AlphaScale = ctx->Pixel.AlphaScale;
 395       save->AlphaBias = ctx->Pixel.AlphaBias;
 396       save->MapColorFlag = ctx->Pixel.MapColorFlag;
 397       ctx->Pixel.RedScale = 1.0F;
 398       ctx->Pixel.RedBias = 0.0F;
 399       ctx->Pixel.GreenScale = 1.0F;
 400       ctx->Pixel.GreenBias = 0.0F;
 401       ctx->Pixel.BlueScale = 1.0F;
 402       ctx->Pixel.BlueBias = 0.0F;
 403       ctx->Pixel.AlphaScale = 1.0F;
 404       ctx->Pixel.AlphaBias = 0.0F;
 405       ctx->Pixel.MapColorFlag = GL_FALSE;
 406       /* XXX more state */
 407       ctx->NewState |=_NEW_PIXEL;
 408    }
 409
 410    if (state & MESA_META_RASTERIZATION) {
 411       save->FrontPolygonMode = ctx->Polygon.FrontMode;
 412       save->BackPolygonMode = ctx->Polygon.BackMode;
 413       save->PolygonOffset = ctx->Polygon.OffsetFill;
 414       save->PolygonSmooth = ctx->Polygon.SmoothFlag;
 415       save->PolygonStipple = ctx->Polygon.StippleFlag;
 416       save->PolygonCull = ctx->Polygon.CullFlag;
 417       _mesa_PolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 418       _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, GL_FALSE);
 419       _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, GL_FALSE);
 420       _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, GL_FALSE);
 421       _mesa_set_enable(ctx, GL_CULL_FACE, GL_FALSE);
 422    }
 423
 424    if (state & MESA_META_SCISSOR) {
 425       save->Scissor = ctx->Scissor; /* struct copy */
 426       _mesa_set_enable(ctx, GL_SCISSOR_TEST, GL_FALSE);
 427    }
 428
 429    if (state & MESA_META_SHADER) {
 430       if (ctx->Extensions.ARB_vertex_program) {
 431          save->VertexProgramEnabled = ctx->VertexProgram.Enabled;
 432          _mesa_reference_vertprog(ctx, &save->VertexProgram,
 433                                   ctx->VertexProgram.Current);
 434          _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB, GL_FALSE);
 435       }
 436
 437       if (ctx->Extensions.ARB_fragment_program) {
 438          save->FragmentProgramEnabled = ctx->FragmentProgram.Enabled;
 439          _mesa_reference_fragprog(ctx, &save->FragmentProgram,
 440                                   ctx->FragmentProgram.Current);
 441          _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_FALSE);
 442       }
 443
 444       if (ctx->Extensions.ARB_shader_objects) {
 445          _mesa_reference_shader_program(ctx, &save->VertexShader,
 446                                         ctx->Shader.CurrentVertexProgram);
 447          _mesa_reference_shader_program(ctx, &save->GeometryShader,
 448                                         ctx->Shader.CurrentGeometryProgram);
 449          _mesa_reference_shader_program(ctx, &save->FragmentShader,
 450                                         ctx->Shader.CurrentFragmentProgram);
 451          _mesa_reference_shader_program(ctx, &save->ActiveShader,
 452                                         ctx->Shader.CurrentFragmentProgram);
 453
 454          _mesa_UseProgramObjectARB(0);
 455       }
 456    }
 457
 458    if (state & MESA_META_STENCIL_TEST) {
 459       save->Stencil = ctx->Stencil; /* struct copy */
 460       if (ctx->Stencil.Enabled)
 461          _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_FALSE);
 462       /* NOTE: other stencil state not reset */
 463    }
 464
 465    if (state & MESA_META_TEXTURE) {
 466       GLuint u, tgt;
 467
 468       save->ActiveUnit = ctx->Texture.CurrentUnit;
 469       save->ClientActiveUnit = ctx->Array.ActiveTexture;
 470       save->EnvMode = ctx->Texture.Unit[0].EnvMode;
 471
 472       /* Disable all texture units */
 473       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 474          save->TexEnabled[u] = ctx->Texture.Unit[u].Enabled;
 475          save->TexGenEnabled[u] = ctx->Texture.Unit[u].TexGenEnabled;
 476          if (ctx->Texture.Unit[u].Enabled ||
 477              ctx->Texture.Unit[u].TexGenEnabled) {
 478             _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
 479             _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_FALSE);
 480             _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_FALSE);
 481             _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_FALSE);
 482             if (ctx->Extensions.ARB_texture_cube_map)
 483                _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
 484             _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_FALSE);
 485             _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_FALSE);
 486             _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_FALSE);
 487             _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_FALSE);
 488             _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_FALSE);
 489          }
 490       }
 491
 492       /* save current texture objects for unit[0] only */
 493       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
 494          _mesa_reference_texobj(&save->CurrentTexture[tgt],
 495                                 ctx->Texture.Unit[0].CurrentTex[tgt]);
 496       }
 497
 498       /* set defaults for unit[0] */
 499       _mesa_ActiveTextureARB(GL_TEXTURE0);
 500       _mesa_ClientActiveTextureARB(GL_TEXTURE0);
 501       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 502    }
 503
 504    if (state & MESA_META_TRANSFORM) {
 505       GLuint activeTexture = ctx->Texture.CurrentUnit;
 506       memcpy(save->ModelviewMatrix, ctx->ModelviewMatrixStack.Top->m,
 507              16 * sizeof(GLfloat));
 508       memcpy(save->ProjectionMatrix, ctx->ProjectionMatrixStack.Top->m,
 509              16 * sizeof(GLfloat));
 510       memcpy(save->TextureMatrix, ctx->TextureMatrixStack[0].Top->m,
 511              16 * sizeof(GLfloat));
 512       save->MatrixMode = ctx->Transform.MatrixMode;
 513       /* set 1:1 vertex:pixel coordinate transform */
 514       _mesa_ActiveTextureARB(GL_TEXTURE0);
 515       _mesa_MatrixMode(GL_TEXTURE);
 516       _mesa_LoadIdentity();
 517       _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
 518       _mesa_MatrixMode(GL_MODELVIEW);
 519       _mesa_LoadIdentity();
 520       _mesa_MatrixMode(GL_PROJECTION);
 521       _mesa_LoadIdentity();
 522       _mesa_Ortho(0.0, ctx->DrawBuffer->Width,
 523                   0.0, ctx->DrawBuffer->Height,
 524                   -1.0, 1.0);
 525    }
 526
 527    if (state & MESA_META_CLIP) {
 528       save->ClipPlanesEnabled = ctx->Transform.ClipPlanesEnabled;
 529       if (ctx->Transform.ClipPlanesEnabled) {
 530          GLuint i;
 531          for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
 532             _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_FALSE);
 533          }
 534       }
 535    }
 536
 537    if (state & MESA_META_VERTEX) {
 538       /* save vertex array object state */
 539       _mesa_reference_array_object(ctx, &save->ArrayObj,
 540                                    ctx->Array.ArrayObj);
 541       _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj,
 542                                     ctx->Array.ArrayBufferObj);
 543       /* set some default state? */
 544    }
 545
 546    if (state & MESA_META_VIEWPORT) {
 547       /* save viewport state */
 548       save->ViewportX = ctx->Viewport.X;
 549       save->ViewportY = ctx->Viewport.Y;
 550       save->ViewportW = ctx->Viewport.Width;
 551       save->ViewportH = ctx->Viewport.Height;
 552       /* set viewport to match window size */
 553       if (ctx->Viewport.X != 0 ||
 554           ctx->Viewport.Y != 0 ||
 555           ctx->Viewport.Width != ctx->DrawBuffer->Width ||
 556           ctx->Viewport.Height != ctx->DrawBuffer->Height) {
 557          _mesa_set_viewport(ctx, 0, 0,
 558                             ctx->DrawBuffer->Width, ctx->DrawBuffer->Height);
 559       }
 560       /* save depth range state */
 561       save->DepthNear = ctx->Viewport.Near;
 562       save->DepthFar = ctx->Viewport.Far;
 563       /* set depth range to default */
 564       _mesa_DepthRange(0.0, 1.0);
 565    }
 566
 567    if (state & MESA_META_CLAMP_FRAGMENT_COLOR) {
 568       save->ClampFragmentColor = ctx->Color.ClampFragmentColor;
 569
 570       /* Generally in here we want to do clamping according to whether
 571        * it's for the pixel path (ClampFragmentColor is GL_TRUE),
 572        * regardless of the internal implementation of the metaops.
 573        */
 574       if (ctx->Color.ClampFragmentColor != GL_TRUE)
 575          _mesa_ClampColorARB(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
 576    }
 577
 578    if (state & MESA_META_CLAMP_VERTEX_COLOR) {
 579       save->ClampVertexColor = ctx->Light.ClampVertexColor;
 580
 581       /* Generally in here we never want vertex color clamping --
 582        * result clamping is only dependent on fragment clamping.
 583        */
 584       _mesa_ClampColorARB(GL_CLAMP_VERTEX_COLOR, GL_FALSE);
 585    }
 586
 587    if (state & MESA_META_CONDITIONAL_RENDER) {
 588       save->CondRenderQuery = ctx->Query.CondRenderQuery;
 589       save->CondRenderMode = ctx->Query.CondRenderMode;
 590
 591       if (ctx->Query.CondRenderQuery)
 592          _mesa_EndConditionalRender();
 593    }
 594
 595    /* misc */
 596    {
 597       save->Lighting = ctx->Light.Enabled;
 598       if (ctx->Light.Enabled)
 599          _mesa_set_enable(ctx, GL_LIGHTING, GL_FALSE);
 600    }
 601 }
 602
 603
 604 /**
 605  * Leave meta state.  This is like a light-weight version of glPopAttrib().
 606  */
 607 void
 608 _mesa_meta_end(struct gl_context *ctx)
 609 {
 610    struct save_state *save = &ctx->Meta->Save[--ctx->Meta->SaveStackDepth];
 611    const GLbitfield state = save->SavedState;
 612
 613    if (state & MESA_META_ALPHA_TEST) {
 614       if (ctx->Color.AlphaEnabled != save->AlphaEnabled)
 615          _mesa_set_enable(ctx, GL_ALPHA_TEST, save->AlphaEnabled);
 616       _mesa_AlphaFunc(save->AlphaFunc, save->AlphaRef);
 617    }
 618
 619    if (state & MESA_META_BLEND) {
 620       if (ctx->Color.BlendEnabled != save->BlendEnabled) {
 621          if (ctx->Extensions.EXT_draw_buffers2) {
 622             GLuint i;
 623             for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 624                _mesa_set_enablei(ctx, GL_BLEND, i, (save->BlendEnabled >> i) & 1);
 625             }
 626          }
 627          else {
 628             _mesa_set_enable(ctx, GL_BLEND, (save->BlendEnabled & 1));
 629          }
 630       }
 631       if (ctx->Color.ColorLogicOpEnabled != save->ColorLogicOpEnabled)
 632          _mesa_set_enable(ctx, GL_COLOR_LOGIC_OP, save->ColorLogicOpEnabled);
 633    }
 634
 635    if (state & MESA_META_COLOR_MASK) {
 636       GLuint i;
 637       for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 638          if (!TEST_EQ_4V(ctx->Color.ColorMask[i], save->ColorMask[i])) {
 639             if (i == 0) {
 640                _mesa_ColorMask(save->ColorMask[i][0], save->ColorMask[i][1],
 641                                save->ColorMask[i][2], save->ColorMask[i][3]);
 642             }
 643             else {
 644                _mesa_ColorMaskIndexed(i,
 645                                       save->ColorMask[i][0],
 646                                       save->ColorMask[i][1],
 647                                       save->ColorMask[i][2],
 648                                       save->ColorMask[i][3]);
 649             }
 650          }
 651       }
 652    }
 653
 654    if (state & MESA_META_DEPTH_TEST) {
 655       if (ctx->Depth.Test != save->Depth.Test)
 656          _mesa_set_enable(ctx, GL_DEPTH_TEST, save->Depth.Test);
 657       _mesa_DepthFunc(save->Depth.Func);
 658       _mesa_DepthMask(save->Depth.Mask);
 659    }
 660
 661    if (state & MESA_META_FOG) {
 662       _mesa_set_enable(ctx, GL_FOG, save->Fog);
 663    }
 664
 665    if (state & MESA_META_PIXEL_STORE) {
 666       ctx->Pack = save->Pack;
 667       ctx->Unpack = save->Unpack;
 668    }
 669
 670    if (state & MESA_META_PIXEL_TRANSFER) {
 671       ctx->Pixel.RedScale = save->RedScale;
 672       ctx->Pixel.RedBias = save->RedBias;
 673       ctx->Pixel.GreenScale = save->GreenScale;
 674       ctx->Pixel.GreenBias = save->GreenBias;
 675       ctx->Pixel.BlueScale = save->BlueScale;
 676       ctx->Pixel.BlueBias = save->BlueBias;
 677       ctx->Pixel.AlphaScale = save->AlphaScale;
 678       ctx->Pixel.AlphaBias = save->AlphaBias;
 679       ctx->Pixel.MapColorFlag = save->MapColorFlag;
 680       /* XXX more state */
 681       ctx->NewState |=_NEW_PIXEL;
 682    }
 683
 684    if (state & MESA_META_RASTERIZATION) {
 685       _mesa_PolygonMode(GL_FRONT, save->FrontPolygonMode);
 686       _mesa_PolygonMode(GL_BACK, save->BackPolygonMode);
 687       _mesa_set_enable(ctx, GL_POLYGON_STIPPLE, save->PolygonStipple);
 688       _mesa_set_enable(ctx, GL_POLYGON_OFFSET_FILL, save->PolygonOffset);
 689       _mesa_set_enable(ctx, GL_POLYGON_SMOOTH, save->PolygonSmooth);
 690       _mesa_set_enable(ctx, GL_CULL_FACE, save->PolygonCull);
 691    }
 692
 693    if (state & MESA_META_SCISSOR) {
 694       _mesa_set_enable(ctx, GL_SCISSOR_TEST, save->Scissor.Enabled);
 695       _mesa_Scissor(save->Scissor.X, save->Scissor.Y,
 696                     save->Scissor.Width, save->Scissor.Height);
 697    }
 698
 699    if (state & MESA_META_SHADER) {
 700       if (ctx->Extensions.ARB_vertex_program) {
 701          _mesa_set_enable(ctx, GL_VERTEX_PROGRAM_ARB,
 702                           save->VertexProgramEnabled);
 703          _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current,
 704                                   save->VertexProgram);
 705          _mesa_reference_vertprog(ctx, &save->VertexProgram, NULL);
 706       }
 707
 708       if (ctx->Extensions.ARB_fragment_program) {
 709          _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB,
 710                           save->FragmentProgramEnabled);
 711          _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current,
 712                                   save->FragmentProgram);
 713          _mesa_reference_fragprog(ctx, &save->FragmentProgram, NULL);
 714       }
 715
 716       if (ctx->Extensions.ARB_vertex_shader)
 717          _mesa_use_shader_program(ctx, GL_VERTEX_SHADER, save->VertexShader);
 718
 719       if (ctx->Extensions.ARB_geometry_shader4)
 720          _mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER_ARB,
 721                                   save->GeometryShader);
 722
 723       if (ctx->Extensions.ARB_fragment_shader)
 724          _mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER,
 725                                   save->FragmentShader);
 726
 727       _mesa_reference_shader_program(ctx, &ctx->Shader.ActiveProgram,
 728                                      save->ActiveShader);
 729    }
 730
 731    if (state & MESA_META_STENCIL_TEST) {
 732       const struct gl_stencil_attrib *stencil = &save->Stencil;
 733
 734       _mesa_set_enable(ctx, GL_STENCIL_TEST, stencil->Enabled);
 735       _mesa_ClearStencil(stencil->Clear);
 736       if (ctx->Extensions.EXT_stencil_two_side) {
 737          _mesa_set_enable(ctx, GL_STENCIL_TEST_TWO_SIDE_EXT,
 738                           stencil->TestTwoSide);
 739          _mesa_ActiveStencilFaceEXT(stencil->ActiveFace
 740                                     ? GL_BACK : GL_FRONT);
 741       }
 742       /* front state */
 743       _mesa_StencilFuncSeparate(GL_FRONT,
 744                                 stencil->Function[0],
 745                                 stencil->Ref[0],
 746                                 stencil->ValueMask[0]);
 747       _mesa_StencilMaskSeparate(GL_FRONT, stencil->WriteMask[0]);
 748       _mesa_StencilOpSeparate(GL_FRONT, stencil->FailFunc[0],
 749                               stencil->ZFailFunc[0],
 750                               stencil->ZPassFunc[0]);
 751       /* back state */
 752       _mesa_StencilFuncSeparate(GL_BACK,
 753                                 stencil->Function[1],
 754                                 stencil->Ref[1],
 755                                 stencil->ValueMask[1]);
 756       _mesa_StencilMaskSeparate(GL_BACK, stencil->WriteMask[1]);
 757       _mesa_StencilOpSeparate(GL_BACK, stencil->FailFunc[1],
 758                               stencil->ZFailFunc[1],
 759                               stencil->ZPassFunc[1]);
 760    }
 761
 762    if (state & MESA_META_TEXTURE) {
 763       GLuint u, tgt;
 764
 765       ASSERT(ctx->Texture.CurrentUnit == 0);
 766
 767       /* restore texenv for unit[0] */
 768       _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, save->EnvMode);
 769
 770       /* restore texture objects for unit[0] only */
 771       for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
 772          _mesa_reference_texobj(&ctx->Texture.Unit[0].CurrentTex[tgt],
 773                                 save->CurrentTexture[tgt]);
 774          _mesa_reference_texobj(&save->CurrentTexture[tgt], NULL);
 775       }
 776
 777       /* Re-enable textures, texgen */
 778       for (u = 0; u < ctx->Const.MaxTextureUnits; u++) {
 779          if (save->TexEnabled[u]) {
 780             _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
 781
 782             if (save->TexEnabled[u] & TEXTURE_1D_BIT)
 783                _mesa_set_enable(ctx, GL_TEXTURE_1D, GL_TRUE);
 784             if (save->TexEnabled[u] & TEXTURE_2D_BIT)
 785                _mesa_set_enable(ctx, GL_TEXTURE_2D, GL_TRUE);
 786             if (save->TexEnabled[u] & TEXTURE_3D_BIT)
 787                _mesa_set_enable(ctx, GL_TEXTURE_3D, GL_TRUE);
 788             if (save->TexEnabled[u] & TEXTURE_CUBE_BIT)
 789                _mesa_set_enable(ctx, GL_TEXTURE_CUBE_MAP, GL_TRUE);
 790             if (save->TexEnabled[u] & TEXTURE_RECT_BIT)
 791                _mesa_set_enable(ctx, GL_TEXTURE_RECTANGLE, GL_TRUE);
 792          }
 793
 794          if (save->TexGenEnabled[u]) {
 795             _mesa_ActiveTextureARB(GL_TEXTURE0 + u);
 796
 797             if (save->TexGenEnabled[u] & S_BIT)
 798                _mesa_set_enable(ctx, GL_TEXTURE_GEN_S, GL_TRUE);
 799             if (save->TexGenEnabled[u] & T_BIT)
 800                _mesa_set_enable(ctx, GL_TEXTURE_GEN_T, GL_TRUE);
 801             if (save->TexGenEnabled[u] & R_BIT)
 802                _mesa_set_enable(ctx, GL_TEXTURE_GEN_R, GL_TRUE);
 803             if (save->TexGenEnabled[u] & Q_BIT)
 804                _mesa_set_enable(ctx, GL_TEXTURE_GEN_Q, GL_TRUE);
 805          }
 806       }
 807
 808       /* restore current unit state */
 809       _mesa_ActiveTextureARB(GL_TEXTURE0 + save->ActiveUnit);
 810       _mesa_ClientActiveTextureARB(GL_TEXTURE0 + save->ClientActiveUnit);
 811    }
 812
 813    if (state & MESA_META_TRANSFORM) {
 814       GLuint activeTexture = ctx->Texture.CurrentUnit;
 815       _mesa_ActiveTextureARB(GL_TEXTURE0);
 816       _mesa_MatrixMode(GL_TEXTURE);
 817       _mesa_LoadMatrixf(save->TextureMatrix);
 818       _mesa_ActiveTextureARB(GL_TEXTURE0 + activeTexture);
 819
 820       _mesa_MatrixMode(GL_MODELVIEW);
 821       _mesa_LoadMatrixf(save->ModelviewMatrix);
 822
 823       _mesa_MatrixMode(GL_PROJECTION);
 824       _mesa_LoadMatrixf(save->ProjectionMatrix);
 825
 826       _mesa_MatrixMode(save->MatrixMode);
 827    }
 828
 829    if (state & MESA_META_CLIP) {
 830       if (save->ClipPlanesEnabled) {
 831          GLuint i;
 832          for (i = 0; i < ctx->Const.MaxClipPlanes; i++) {
 833             if (save->ClipPlanesEnabled & (1 << i)) {
 834                _mesa_set_enable(ctx, GL_CLIP_PLANE0 + i, GL_TRUE);
 835             }
 836          }
 837       }
 838    }
 839
 840    if (state & MESA_META_VERTEX) {
 841       /* restore vertex buffer object */
 842       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, save->ArrayBufferObj->Name);
 843       _mesa_reference_buffer_object(ctx, &save->ArrayBufferObj, NULL);
 844
 845       /* restore vertex array object */
 846       _mesa_BindVertexArray(save->ArrayObj->Name);
 847       _mesa_reference_array_object(ctx, &save->ArrayObj, NULL);
 848    }
 849
 850    if (state & MESA_META_VIEWPORT) {
 851       if (save->ViewportX != ctx->Viewport.X ||
 852           save->ViewportY != ctx->Viewport.Y ||
 853           save->ViewportW != ctx->Viewport.Width ||
 854           save->ViewportH != ctx->Viewport.Height) {
 855          _mesa_set_viewport(ctx, save->ViewportX, save->ViewportY,
 856                             save->ViewportW, save->ViewportH);
 857       }
 858       _mesa_DepthRange(save->DepthNear, save->DepthFar);
 859    }
 860
 861    if (state & MESA_META_CLAMP_FRAGMENT_COLOR) {
 862       _mesa_ClampColorARB(GL_CLAMP_FRAGMENT_COLOR, save->ClampFragmentColor);
 863    }
 864
 865    if (state & MESA_META_CLAMP_VERTEX_COLOR) {
 866       _mesa_ClampColorARB(GL_CLAMP_VERTEX_COLOR, save->ClampVertexColor);
 867    }
 868
 869    if (state & MESA_META_CONDITIONAL_RENDER) {
 870       if (save->CondRenderQuery)
 871          _mesa_BeginConditionalRender(save->CondRenderQuery->Id,
 872                                       save->CondRenderMode);
 873    }
 874
 875    /* misc */
 876    if (save->Lighting) {
 877       _mesa_set_enable(ctx, GL_LIGHTING, GL_TRUE);
 878    }
 879 }
 880
 881
 882 /**
 883  * Convert Z from a normalized value in the range [0, 1] to an object-space
 884  * Z coordinate in [-1, +1] so that drawing at the new Z position with the
 885  * default/identity ortho projection results in the original Z value.
 886  * Used by the meta-Clear, Draw/CopyPixels and Bitmap functions where the Z
 887  * value comes from the clear value or raster position.
 888  */
 889 static INLINE GLfloat
 890 invert_z(GLfloat normZ)
 891 {
 892    GLfloat objZ = 1.0 - 2.0 * normZ;
 893    return objZ;
 894 }
 895
 896
 897 /**
 898  * One-time init for a temp_texture object.
 899  * Choose tex target, compute max tex size, etc.
 900  */
 901 static void
 902 init_temp_texture(struct gl_context *ctx, struct temp_texture *tex)
 903 {
 904    /* prefer texture rectangle */
 905    if (ctx->Extensions.NV_texture_rectangle) {
 906       tex->Target = GL_TEXTURE_RECTANGLE;
 907       tex->MaxSize = ctx->Const.MaxTextureRectSize;
 908       tex->NPOT = GL_TRUE;
 909    }
 910    else {
 911       /* use 2D texture, NPOT if possible */
 912       tex->Target = GL_TEXTURE_2D;
 913       tex->MaxSize = 1 << (ctx->Const.MaxTextureLevels - 1);
 914       tex->NPOT = ctx->Extensions.ARB_texture_non_power_of_two;
 915    }
 916    tex->MinSize = 16;  /* 16 x 16 at least */
 917    assert(tex->MaxSize > 0);
 918
 919    _mesa_GenTextures(1, &tex->TexObj);
 920 }
 921
 922
 923 /**
 924  * Return pointer to temp_texture info for non-bitmap ops.
 925  * This does some one-time init if needed.
 926  */
 927 static struct temp_texture *
 928 get_temp_texture(struct gl_context *ctx)
 929 {
 930    struct temp_texture *tex = &ctx->Meta->TempTex;
 931
 932    if (!tex->TexObj) {
 933       init_temp_texture(ctx, tex);
 934    }
 935
 936    return tex;
 937 }
 938
 939
 940 /**
 941  * Return pointer to temp_texture info for _mesa_meta_bitmap().
 942  * We use a separate texture for bitmaps to reduce texture
 943  * allocation/deallocation.
 944  */
 945 static struct temp_texture *
 946 get_bitmap_temp_texture(struct gl_context *ctx)
 947 {
 948    struct temp_texture *tex = &ctx->Meta->Bitmap.Tex;
 949
 950    if (!tex->TexObj) {
 951       init_temp_texture(ctx, tex);
 952    }
 953
 954    return tex;
 955 }
 956
 957
 958 /**
 959  * Compute the width/height of texture needed to draw an image of the
 960  * given size.  Return a flag indicating whether the current texture
 961  * can be re-used (glTexSubImage2D) or if a new texture needs to be
 962  * allocated (glTexImage2D).
 963  * Also, compute s/t texcoords for drawing.
 964  *
 965  * \return GL_TRUE if new texture is needed, GL_FALSE otherwise
 966  */
 967 static GLboolean
 968 alloc_texture(struct temp_texture *tex,
 969               GLsizei width, GLsizei height, GLenum intFormat)
 970 {
 971    GLboolean newTex = GL_FALSE;
 972
 973    ASSERT(width <= tex->MaxSize);
 974    ASSERT(height <= tex->MaxSize);
 975
 976    if (width > tex->Width ||
 977        height > tex->Height ||
 978        intFormat != tex->IntFormat) {
 979       /* alloc new texture (larger or different format) */
 980
 981       if (tex->NPOT) {
 982          /* use non-power of two size */
 983          tex->Width = MAX2(tex->MinSize, width);
 984          tex->Height = MAX2(tex->MinSize, height);
 985       }
 986       else {
 987          /* find power of two size */
 988          GLsizei w, h;
 989          w = h = tex->MinSize;
 990          while (w < width)
 991             w *= 2;
 992          while (h < height)
 993             h *= 2;
 994          tex->Width = w;
 995          tex->Height = h;
 996       }
 997
 998       tex->IntFormat = intFormat;
 999
1000       newTex = GL_TRUE;
1001    }
1002
1003    /* compute texcoords */
1004    if (tex->Target == GL_TEXTURE_RECTANGLE) {
1005       tex->Sright = (GLfloat) width;
1006       tex->Ttop = (GLfloat) height;
1007    }
1008    else {
1009       tex->Sright = (GLfloat) width / tex->Width;
1010       tex->Ttop = (GLfloat) height / tex->Height;
1011    }
1012
1013    return newTex;
1014 }
1015
1016
1017 /**
1018  * Setup/load texture for glCopyPixels or glBlitFramebuffer.
1019  */
1020 static void
1021 setup_copypix_texture(struct temp_texture *tex,
1022                       GLboolean newTex,
1023                       GLint srcX, GLint srcY,
1024                       GLsizei width, GLsizei height, GLenum intFormat,
1025                       GLenum filter)
1026 {
1027    _mesa_BindTexture(tex->Target, tex->TexObj);
1028    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, filter);
1029    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, filter);
1030    _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1031
1032    /* copy framebuffer image to texture */
1033    if (newTex) {
1034       /* create new tex image */
1035       if (tex->Width == width && tex->Height == height) {
1036          /* create new tex with framebuffer data */
1037          _mesa_CopyTexImage2D(tex->Target, 0, tex->IntFormat,
1038                               srcX, srcY, width, height, 0);
1039       }
1040       else {
1041          /* create empty texture */
1042          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
1043                           tex->Width, tex->Height, 0,
1044                           intFormat, GL_UNSIGNED_BYTE, NULL);
1045          /* load image */
1046          _mesa_CopyTexSubImage2D(tex->Target, 0,
1047                                  0, 0, srcX, srcY, width, height);
1048       }
1049    }
1050    else {
1051       /* replace existing tex image */
1052       _mesa_CopyTexSubImage2D(tex->Target, 0,
1053                               0, 0, srcX, srcY, width, height);
1054    }
1055 }
1056
1057
1058 /**
1059  * Setup/load texture for glDrawPixels.
1060  */
1061 static void
1062 setup_drawpix_texture(struct gl_context *ctx,
1063                       struct temp_texture *tex,
1064                       GLboolean newTex,
1065                       GLenum texIntFormat,
1066                       GLsizei width, GLsizei height,
1067                       GLenum format, GLenum type,
1068                       const GLvoid *pixels)
1069 {
1070    _mesa_BindTexture(tex->Target, tex->TexObj);
1071    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1072    _mesa_TexParameteri(tex->Target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1073    _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1074
1075    /* copy pixel data to texture */
1076    if (newTex) {
1077       /* create new tex image */
1078       if (tex->Width == width && tex->Height == height) {
1079          /* create new tex and load image data */
1080          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
1081                           tex->Width, tex->Height, 0, format, type, pixels);
1082       }
1083       else {
1084          struct gl_buffer_object *save_unpack_obj = NULL;
1085
1086          _mesa_reference_buffer_object(ctx, &save_unpack_obj,
1087                                        ctx->Unpack.BufferObj);
1088          _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
1089          /* create empty texture */
1090          _mesa_TexImage2D(tex->Target, 0, tex->IntFormat,
1091                           tex->Width, tex->Height, 0, format, type, NULL);
1092          if (save_unpack_obj != NULL)
1093             _mesa_BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
1094                                 save_unpack_obj->Name);
1095          /* load image */
1096          _mesa_TexSubImage2D(tex->Target, 0,
1097                              0, 0, width, height, format, type, pixels);
1098       }
1099    }
1100    else {
1101       /* replace existing tex image */
1102       _mesa_TexSubImage2D(tex->Target, 0,
1103                           0, 0, width, height, format, type, pixels);
1104    }
1105 }
1106
1107
1108
1109 /**
1110  * One-time init for drawing depth pixels.
1111  */
1112 static void
1113 init_blit_depth_pixels(struct gl_context *ctx)
1114 {
1115    static const char *program =
1116       "!!ARBfp1.0\n"
1117       "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
1118       "END \n";
1119    char program2[200];
1120    struct blit_state *blit = &ctx->Meta->Blit;
1121    struct temp_texture *tex = get_temp_texture(ctx);
1122    const char *texTarget;
1123
1124    assert(blit->DepthFP == 0);
1125
1126    /* replace %s with "RECT" or "2D" */
1127    assert(strlen(program) + 4 < sizeof(program2));
1128    if (tex->Target == GL_TEXTURE_RECTANGLE)
1129       texTarget = "RECT";
1130    else
1131       texTarget = "2D";
1132    _mesa_snprintf(program2, sizeof(program2), program, texTarget);
1133
1134    _mesa_GenPrograms(1, &blit->DepthFP);
1135    _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
1136    _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
1137                           strlen(program2), (const GLubyte *) program2);
1138 }
1139
1140
1141 /**
1142  * Try to do a glBlitFramebuffer using no-copy texturing.
1143  * We can do this when the src renderbuffer is actually a texture.
1144  * But if the src buffer == dst buffer we cannot do this.
1145  *
1146  * \return new buffer mask indicating the buffers left to blit using the
1147  *         normal path.
1148  */
1149 static GLbitfield
1150 blitframebuffer_texture(struct gl_context *ctx,
1151                         GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
1152                         GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
1153                         GLbitfield mask, GLenum filter)
1154 {
1155    if (mask & GL_COLOR_BUFFER_BIT) {
1156       const struct gl_framebuffer *drawFb = ctx->DrawBuffer;
1157       const struct gl_framebuffer *readFb = ctx->ReadBuffer;
1158       const struct gl_renderbuffer_attachment *drawAtt =
1159          &drawFb->Attachment[drawFb->_ColorDrawBufferIndexes[0]];
1160       const struct gl_renderbuffer_attachment *readAtt =
1161          &readFb->Attachment[readFb->_ColorReadBufferIndex];
1162
1163       if (readAtt && readAtt->Texture) {
1164          const struct gl_texture_object *texObj = readAtt->Texture;
1165          const GLuint srcLevel = readAtt->TextureLevel;
1166          const GLenum minFilterSave = texObj->Sampler.MinFilter;
1167          const GLenum magFilterSave = texObj->Sampler.MagFilter;
1168          const GLint baseLevelSave = texObj->BaseLevel;
1169          const GLint maxLevelSave = texObj->MaxLevel;
1170          const GLenum wrapSSave = texObj->Sampler.WrapS;
1171          const GLenum wrapTSave = texObj->Sampler.WrapT;
1172          const GLenum srgbSave = texObj->Sampler.sRGBDecode;
1173          const GLenum fbo_srgb_save = ctx->Color.sRGBEnabled;
1174          const GLenum target = texObj->Target;
1175
1176          if (drawAtt->Texture == readAtt->Texture) {
1177             /* Can't use same texture as both the source and dest.  We need
1178              * to handle overlapping blits and besides, some hw may not
1179              * support this.
1180              */
1181             return mask;
1182          }
1183
1184          if (target != GL_TEXTURE_2D && target != GL_TEXTURE_RECTANGLE_ARB) {
1185             /* Can't handle other texture types at this time */
1186             return mask;
1187          }
1188
1189          /*
1190          printf("Blit from texture!\n");
1191          printf("  srcAtt %p  dstAtt %p\n", readAtt, drawAtt);
1192          printf("  srcTex %p  dstText %p\n", texObj, drawAtt->Texture);
1193          */
1194
1195          /* Prepare src texture state */
1196          _mesa_BindTexture(target, texObj->Name);
1197          _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
1198          _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
1199          if (target != GL_TEXTURE_RECTANGLE_ARB) {
1200             _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, srcLevel);
1201             _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);
1202          }
1203          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1204          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1205
1206          /* Always do our blits with no sRGB decode or encode.*/
1207          if (ctx->Extensions.EXT_texture_sRGB_decode) {
1208             _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT,
1209                                 GL_SKIP_DECODE_EXT);
1210          }
1211          _mesa_Disable(GL_FRAMEBUFFER_SRGB_EXT);
1212
1213          _mesa_TexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
1214          _mesa_set_enable(ctx, target, GL_TRUE);
1215
1216          /* Prepare vertex data (the VBO was previously created and bound) */
1217          {
1218             struct vertex {
1219                GLfloat x, y, s, t;
1220             };
1221             struct vertex verts[4];
1222             GLfloat s0, t0, s1, t1;
1223
1224             if (target == GL_TEXTURE_2D) {
1225                const struct gl_texture_image *texImage
1226                    = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
1227                s0 = srcX0 / (float) texImage->Width;
1228                s1 = srcX1 / (float) texImage->Width;
1229                t0 = srcY0 / (float) texImage->Height;
1230                t1 = srcY1 / (float) texImage->Height;
1231             }
1232             else {
1233                assert(target == GL_TEXTURE_RECTANGLE_ARB);
1234                s0 = srcX0;
1235                s1 = srcX1;
1236                t0 = srcY0;
1237                t1 = srcY1;
1238             }
1239
1240             verts[0].x = (GLfloat) dstX0;
1241             verts[0].y = (GLfloat) dstY0;
1242             verts[1].x = (GLfloat) dstX1;
1243             verts[1].y = (GLfloat) dstY0;
1244             verts[2].x = (GLfloat) dstX1;
1245             verts[2].y = (GLfloat) dstY1;
1246             verts[3].x = (GLfloat) dstX0;
1247             verts[3].y = (GLfloat) dstY1;
1248
1249             verts[0].s = s0;
1250             verts[0].t = t0;
1251             verts[1].s = s1;
1252             verts[1].t = t0;
1253             verts[2].s = s1;
1254             verts[2].t = t1;
1255             verts[3].s = s0;
1256             verts[3].t = t1;
1257
1258             _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1259          }
1260
1261          _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1262
1263          /* Restore texture object state, the texture binding will
1264           * be restored by _mesa_meta_end().
1265           */
1266          _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
1267          _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
1268          if (target != GL_TEXTURE_RECTANGLE_ARB) {
1269             _mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, baseLevelSave);
1270             _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
1271          }
1272          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
1273          _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
1274          if (ctx->Extensions.EXT_texture_sRGB_decode) {
1275             _mesa_TexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT, srgbSave);
1276          }
1277          if (ctx->Extensions.EXT_texture_sRGB_decode && fbo_srgb_save) {
1278             _mesa_Enable(GL_FRAMEBUFFER_SRGB_EXT);
1279          }
1280
1281          /* Done with color buffer */
1282          mask &= ~GL_COLOR_BUFFER_BIT;
1283       }
1284    }
1285
1286    return mask;
1287 }
1288
1289
1290 /**
1291  * Meta implementation of ctx->Driver.BlitFramebuffer() in terms
1292  * of texture mapping and polygon rendering.
1293  */
1294 void
1295 _mesa_meta_BlitFramebuffer(struct gl_context *ctx,
1296                            GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
1297                            GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
1298                            GLbitfield mask, GLenum filter)
1299 {
1300    struct blit_state *blit = &ctx->Meta->Blit;
1301    struct temp_texture *tex = get_temp_texture(ctx);
1302    const GLsizei maxTexSize = tex->MaxSize;
1303    const GLint srcX = MIN2(srcX0, srcX1);
1304    const GLint srcY = MIN2(srcY0, srcY1);
1305    const GLint srcW = abs(srcX1 - srcX0);
1306    const GLint srcH = abs(srcY1 - srcY0);
1307    const GLboolean srcFlipX = srcX1 < srcX0;
1308    const GLboolean srcFlipY = srcY1 < srcY0;
1309    struct vertex {
1310       GLfloat x, y, s, t;
1311    };
1312    struct vertex verts[4];
1313    GLboolean newTex;
1314
1315    if (srcW > maxTexSize || srcH > maxTexSize) {
1316       /* XXX avoid this fallback */
1317       _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
1318                               dstX0, dstY0, dstX1, dstY1, mask, filter);
1319       return;
1320    }
1321
1322    if (srcFlipX) {
1323       GLint tmp = dstX0;
1324       dstX0 = dstX1;
1325       dstX1 = tmp;
1326    }
1327
1328    if (srcFlipY) {
1329       GLint tmp = dstY0;
1330       dstY0 = dstY1;
1331       dstY1 = tmp;
1332    }
1333
1334    /* only scissor effects blit so save/clear all other relevant state */
1335    _mesa_meta_begin(ctx, ~MESA_META_SCISSOR);
1336
1337    if (blit->ArrayObj == 0) {
1338       /* one-time setup */
1339
1340       /* create vertex array object */
1341       _mesa_GenVertexArrays(1, &blit->ArrayObj);
1342       _mesa_BindVertexArray(blit->ArrayObj);
1343
1344       /* create vertex array buffer */
1345       _mesa_GenBuffersARB(1, &blit->VBO);
1346       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
1347       _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1348                           NULL, GL_DYNAMIC_DRAW_ARB);
1349
1350       /* setup vertex arrays */
1351       _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
1352       _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
1353       _mesa_EnableClientState(GL_VERTEX_ARRAY);
1354       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1355    }
1356    else {
1357       _mesa_BindVertexArray(blit->ArrayObj);
1358       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, blit->VBO);
1359    }
1360
1361    /* Try faster, direct texture approach first */
1362    mask = blitframebuffer_texture(ctx, srcX0, srcY0, srcX1, srcY1,
1363                                   dstX0, dstY0, dstX1, dstY1, mask, filter);
1364    if (mask == 0x0) {
1365       _mesa_meta_end(ctx);
1366       return;
1367    }
1368
1369    /* Continue with "normal" approach which involves copying the src rect
1370     * into a temporary texture and is "blitted" by drawing a textured quad.
1371     */
1372
1373    newTex = alloc_texture(tex, srcW, srcH, GL_RGBA);
1374
1375    /* vertex positions/texcoords (after texture allocation!) */
1376    {
1377       verts[0].x = (GLfloat) dstX0;
1378       verts[0].y = (GLfloat) dstY0;
1379       verts[1].x = (GLfloat) dstX1;
1380       verts[1].y = (GLfloat) dstY0;
1381       verts[2].x = (GLfloat) dstX1;
1382       verts[2].y = (GLfloat) dstY1;
1383       verts[3].x = (GLfloat) dstX0;
1384       verts[3].y = (GLfloat) dstY1;
1385
1386       verts[0].s = 0.0F;
1387       verts[0].t = 0.0F;
1388       verts[1].s = tex->Sright;
1389       verts[1].t = 0.0F;
1390       verts[2].s = tex->Sright;
1391       verts[2].t = tex->Ttop;
1392       verts[3].s = 0.0F;
1393       verts[3].t = tex->Ttop;
1394
1395       /* upload new vertex data */
1396       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1397    }
1398
1399    _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1400
1401    if (mask & GL_COLOR_BUFFER_BIT) {
1402       setup_copypix_texture(tex, newTex, srcX, srcY, srcW, srcH,
1403                             GL_RGBA, filter);
1404       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1405       mask &= ~GL_COLOR_BUFFER_BIT;
1406    }
1407
1408    if (mask & GL_DEPTH_BUFFER_BIT) {
1409       GLuint *tmp = (GLuint *) malloc(srcW * srcH * sizeof(GLuint));
1410       if (tmp) {
1411          if (!blit->DepthFP)
1412             init_blit_depth_pixels(ctx);
1413
1414          /* maybe change tex format here */
1415          newTex = alloc_texture(tex, srcW, srcH, GL_DEPTH_COMPONENT);
1416
1417          _mesa_ReadPixels(srcX, srcY, srcW, srcH,
1418                           GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
1419
1420          setup_drawpix_texture(ctx, tex, newTex, GL_DEPTH_COMPONENT, srcW, srcH,
1421                                GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, tmp);
1422
1423          _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, blit->DepthFP);
1424          _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
1425          _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1426          _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1427          _mesa_DepthFunc(GL_ALWAYS);
1428          _mesa_DepthMask(GL_TRUE);
1429
1430          _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1431          mask &= ~GL_DEPTH_BUFFER_BIT;
1432
1433          free(tmp);
1434       }
1435    }
1436
1437    if (mask & GL_STENCIL_BUFFER_BIT) {
1438       /* XXX can't easily do stencil */
1439    }
1440
1441    _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1442
1443    _mesa_meta_end(ctx);
1444
1445    if (mask) {
1446       _swrast_BlitFramebuffer(ctx, srcX0, srcY0, srcX1, srcY1,
1447                               dstX0, dstY0, dstX1, dstY1, mask, filter);
1448    }
1449 }
1450
1451
1452 /**
1453  * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
1454  */
1455 void
1456 _mesa_meta_Clear(struct gl_context *ctx, GLbitfield buffers)
1457 {
1458    struct clear_state *clear = &ctx->Meta->Clear;
1459    struct vertex {
1460       GLfloat x, y, z, r, g, b, a;
1461    };
1462    struct vertex verts[4];
1463    /* save all state but scissor, pixel pack/unpack */
1464    GLbitfield metaSave = (MESA_META_ALL -
1465                           MESA_META_SCISSOR -
1466                           MESA_META_PIXEL_STORE -
1467                           MESA_META_CONDITIONAL_RENDER);
1468    const GLuint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
1469
1470    if (buffers & BUFFER_BITS_COLOR) {
1471       /* if clearing color buffers, don't save/restore colormask */
1472       metaSave -= MESA_META_COLOR_MASK;
1473    }
1474
1475    _mesa_meta_begin(ctx, metaSave);
1476
1477    if (clear->ArrayObj == 0) {
1478       /* one-time setup */
1479
1480       /* create vertex array object */
1481       _mesa_GenVertexArrays(1, &clear->ArrayObj);
1482       _mesa_BindVertexArray(clear->ArrayObj);
1483
1484       /* create vertex array buffer */
1485       _mesa_GenBuffersARB(1, &clear->VBO);
1486       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1487
1488       /* setup vertex arrays */
1489       _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
1490       _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
1491       _mesa_EnableClientState(GL_VERTEX_ARRAY);
1492       _mesa_EnableClientState(GL_COLOR_ARRAY);
1493    }
1494    else {
1495       _mesa_BindVertexArray(clear->ArrayObj);
1496       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1497    }
1498
1499    /* GL_COLOR_BUFFER_BIT */
1500    if (buffers & BUFFER_BITS_COLOR) {
1501       /* leave colormask, glDrawBuffer state as-is */
1502
1503       /* Clears never have the color clamped. */
1504       _mesa_ClampColorARB(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
1505    }
1506    else {
1507       ASSERT(metaSave & MESA_META_COLOR_MASK);
1508       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1509    }
1510
1511    /* GL_DEPTH_BUFFER_BIT */
1512    if (buffers & BUFFER_BIT_DEPTH) {
1513       _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1514       _mesa_DepthFunc(GL_ALWAYS);
1515       _mesa_DepthMask(GL_TRUE);
1516    }
1517    else {
1518       assert(!ctx->Depth.Test);
1519    }
1520
1521    /* GL_STENCIL_BUFFER_BIT */
1522    if (buffers & BUFFER_BIT_STENCIL) {
1523       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
1524       _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,
1525                               GL_REPLACE, GL_REPLACE, GL_REPLACE);
1526       _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,
1527                                 ctx->Stencil.Clear & stencilMax,
1528                                 ctx->Stencil.WriteMask[0]);
1529    }
1530    else {
1531       assert(!ctx->Stencil.Enabled);
1532    }
1533
1534    /* vertex positions/colors */
1535    {
1536       const GLfloat x0 = (GLfloat) ctx->DrawBuffer->_Xmin;
1537       const GLfloat y0 = (GLfloat) ctx->DrawBuffer->_Ymin;
1538       const GLfloat x1 = (GLfloat) ctx->DrawBuffer->_Xmax;
1539       const GLfloat y1 = (GLfloat) ctx->DrawBuffer->_Ymax;
1540       const GLfloat z = invert_z(ctx->Depth.Clear);
1541       GLuint i;
1542
1543       verts[0].x = x0;
1544       verts[0].y = y0;
1545       verts[0].z = z;
1546       verts[1].x = x1;
1547       verts[1].y = y0;
1548       verts[1].z = z;
1549       verts[2].x = x1;
1550       verts[2].y = y1;
1551       verts[2].z = z;
1552       verts[3].x = x0;
1553       verts[3].y = y1;
1554       verts[3].z = z;
1555
1556       /* vertex colors */
1557       for (i = 0; i < 4; i++) {
1558          verts[i].r = ctx->Color.ClearColorUnclamped[0];
1559          verts[i].g = ctx->Color.ClearColorUnclamped[1];
1560          verts[i].b = ctx->Color.ClearColorUnclamped[2];
1561          verts[i].a = ctx->Color.ClearColorUnclamped[3];
1562       }
1563
1564       /* upload new vertex data */
1565       _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,
1566                           GL_DYNAMIC_DRAW_ARB);
1567    }
1568
1569    /* draw quad */
1570    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1571
1572    _mesa_meta_end(ctx);
1573 }
1574
1575 static void
1576 meta_glsl_clear_init(struct gl_context *ctx, struct clear_state *clear)
1577 {
1578    const char *vs_source =
1579       "attribute vec4 position;\n"
1580       "void main()\n"
1581       "{\n"
1582       "   gl_Position = position;\n"
1583       "}\n";
1584    const char *fs_source =
1585       "uniform vec4 color;\n"
1586       "void main()\n"
1587       "{\n"
1588       "   gl_FragColor = color;\n"
1589       "}\n";
1590    GLuint vs, fs;
1591
1592    if (clear->ArrayObj != 0)
1593       return;
1594
1595    /* create vertex array object */
1596    _mesa_GenVertexArrays(1, &clear->ArrayObj);
1597    _mesa_BindVertexArray(clear->ArrayObj);
1598
1599    /* create vertex array buffer */
1600    _mesa_GenBuffersARB(1, &clear->VBO);
1601    _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1602
1603    /* setup vertex arrays */
1604    _mesa_VertexAttribPointerARB(0, 3, GL_FLOAT, GL_FALSE, 0, (void *)0);
1605    _mesa_EnableVertexAttribArrayARB(0);
1606
1607    vs = _mesa_CreateShaderObjectARB(GL_VERTEX_SHADER);
1608    _mesa_ShaderSourceARB(vs, 1, &vs_source, NULL);
1609    _mesa_CompileShaderARB(vs);
1610
1611    fs = _mesa_CreateShaderObjectARB(GL_FRAGMENT_SHADER);
1612    _mesa_ShaderSourceARB(fs, 1, &fs_source, NULL);
1613    _mesa_CompileShaderARB(fs);
1614
1615    clear->ShaderProg = _mesa_CreateProgramObjectARB();
1616    _mesa_AttachShader(clear->ShaderProg, fs);
1617    _mesa_AttachShader(clear->ShaderProg, vs);
1618    _mesa_BindAttribLocationARB(clear->ShaderProg, 0, "position");
1619    _mesa_LinkProgramARB(clear->ShaderProg);
1620
1621    clear->ColorLocation = _mesa_GetUniformLocationARB(clear->ShaderProg,
1622                                                       "color");
1623 }
1624
1625 /**
1626  * Meta implementation of ctx->Driver.Clear() in terms of polygon rendering.
1627  */
1628 void
1629 _mesa_meta_glsl_Clear(struct gl_context *ctx, GLbitfield buffers)
1630 {
1631    struct clear_state *clear = &ctx->Meta->Clear;
1632    GLbitfield metaSave;
1633    const GLuint stencilMax = (1 << ctx->DrawBuffer->Visual.stencilBits) - 1;
1634    struct gl_framebuffer *fb = ctx->DrawBuffer;
1635    const float x0 = ((float)fb->_Xmin / fb->Width)  * 2.0f - 1.0f;
1636    const float y0 = ((float)fb->_Ymin / fb->Height) * 2.0f - 1.0f;
1637    const float x1 = ((float)fb->_Xmax / fb->Width)  * 2.0f - 1.0f;
1638    const float y1 = ((float)fb->_Ymax / fb->Height) * 2.0f - 1.0f;
1639    const float z = -invert_z(ctx->Depth.Clear);
1640    struct vertex {
1641       GLfloat x, y, z;
1642    } verts[4];
1643
1644    metaSave = (MESA_META_ALPHA_TEST |
1645                MESA_META_BLEND |
1646                MESA_META_DEPTH_TEST |
1647                MESA_META_RASTERIZATION |
1648                MESA_META_SHADER |
1649                MESA_META_STENCIL_TEST |
1650                MESA_META_VERTEX |
1651                MESA_META_VIEWPORT |
1652                MESA_META_CLIP |
1653                MESA_META_CLAMP_FRAGMENT_COLOR);
1654
1655    if (!(buffers & BUFFER_BITS_COLOR)) {
1656       /* We'll use colormask to disable color writes.  Otherwise,
1657        * respect color mask
1658        */
1659       metaSave |= MESA_META_COLOR_MASK;
1660    }
1661
1662    _mesa_meta_begin(ctx, metaSave);
1663
1664    meta_glsl_clear_init(ctx, clear);
1665
1666    _mesa_UseProgramObjectARB(clear->ShaderProg);
1667    _mesa_Uniform4fvARB(clear->ColorLocation, 1,
1668                        ctx->Color.ClearColorUnclamped);
1669
1670    _mesa_BindVertexArray(clear->ArrayObj);
1671    _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, clear->VBO);
1672
1673    /* GL_COLOR_BUFFER_BIT */
1674    if (buffers & BUFFER_BITS_COLOR) {
1675       /* leave colormask, glDrawBuffer state as-is */
1676
1677       /* Clears never have the color clamped. */
1678       _mesa_ClampColorARB(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
1679    }
1680    else {
1681       ASSERT(metaSave & MESA_META_COLOR_MASK);
1682       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1683    }
1684
1685    /* GL_DEPTH_BUFFER_BIT */
1686    if (buffers & BUFFER_BIT_DEPTH) {
1687       _mesa_set_enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1688       _mesa_DepthFunc(GL_ALWAYS);
1689       _mesa_DepthMask(GL_TRUE);
1690    }
1691    else {
1692       assert(!ctx->Depth.Test);
1693    }
1694
1695    /* GL_STENCIL_BUFFER_BIT */
1696    if (buffers & BUFFER_BIT_STENCIL) {
1697       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
1698       _mesa_StencilOpSeparate(GL_FRONT_AND_BACK,
1699                               GL_REPLACE, GL_REPLACE, GL_REPLACE);
1700       _mesa_StencilFuncSeparate(GL_FRONT_AND_BACK, GL_ALWAYS,
1701                                 ctx->Stencil.Clear & stencilMax,
1702                                 ctx->Stencil.WriteMask[0]);
1703    }
1704    else {
1705       assert(!ctx->Stencil.Enabled);
1706    }
1707
1708    /* vertex positions */
1709    verts[0].x = x0;
1710    verts[0].y = y0;
1711    verts[0].z = z;
1712    verts[1].x = x1;
1713    verts[1].y = y0;
1714    verts[1].z = z;
1715    verts[2].x = x1;
1716    verts[2].y = y1;
1717    verts[2].z = z;
1718    verts[3].x = x0;
1719    verts[3].y = y1;
1720    verts[3].z = z;
1721
1722    /* upload new vertex data */
1723    _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts), verts,
1724                        GL_DYNAMIC_DRAW_ARB);
1725
1726    /* draw quad */
1727    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1728
1729    _mesa_meta_end(ctx);
1730 }
1731
1732 /**
1733  * Meta implementation of ctx->Driver.CopyPixels() in terms
1734  * of texture mapping and polygon rendering and GLSL shaders.
1735  */
1736 void
1737 _mesa_meta_CopyPixels(struct gl_context *ctx, GLint srcX, GLint srcY,
1738                       GLsizei width, GLsizei height,
1739                       GLint dstX, GLint dstY, GLenum type)
1740 {
1741    struct copypix_state *copypix = &ctx->Meta->CopyPix;
1742    struct temp_texture *tex = get_temp_texture(ctx);
1743    struct vertex {
1744       GLfloat x, y, z, s, t;
1745    };
1746    struct vertex verts[4];
1747    GLboolean newTex;
1748    GLenum intFormat = GL_RGBA;
1749
1750    if (type != GL_COLOR ||
1751        ctx->_ImageTransferState ||
1752        ctx->Fog.Enabled ||
1753        width > tex->MaxSize ||
1754        height > tex->MaxSize) {
1755       /* XXX avoid this fallback */
1756       _swrast_CopyPixels(ctx, srcX, srcY, width, height, dstX, dstY, type);
1757       return;
1758    }
1759
1760    /* Most GL state applies to glCopyPixels, but a there's a few things
1761     * we need to override:
1762     */
1763    _mesa_meta_begin(ctx, (MESA_META_RASTERIZATION |
1764                           MESA_META_SHADER |
1765                           MESA_META_TEXTURE |
1766                           MESA_META_TRANSFORM |
1767                           MESA_META_CLIP |
1768                           MESA_META_VERTEX |
1769                           MESA_META_VIEWPORT));
1770
1771    if (copypix->ArrayObj == 0) {
1772       /* one-time setup */
1773
1774       /* create vertex array object */
1775       _mesa_GenVertexArrays(1, &copypix->ArrayObj);
1776       _mesa_BindVertexArray(copypix->ArrayObj);
1777
1778       /* create vertex array buffer */
1779       _mesa_GenBuffersARB(1, &copypix->VBO);
1780       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
1781       _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
1782                           NULL, GL_DYNAMIC_DRAW_ARB);
1783
1784       /* setup vertex arrays */
1785       _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
1786       _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
1787       _mesa_EnableClientState(GL_VERTEX_ARRAY);
1788       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
1789    }
1790    else {
1791       _mesa_BindVertexArray(copypix->ArrayObj);
1792       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, copypix->VBO);
1793    }
1794
1795    newTex = alloc_texture(tex, width, height, intFormat);
1796
1797    /* vertex positions, texcoords (after texture allocation!) */
1798    {
1799       const GLfloat dstX0 = (GLfloat) dstX;
1800       const GLfloat dstY0 = (GLfloat) dstY;
1801       const GLfloat dstX1 = dstX + width * ctx->Pixel.ZoomX;
1802       const GLfloat dstY1 = dstY + height * ctx->Pixel.ZoomY;
1803       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
1804
1805       verts[0].x = dstX0;
1806       verts[0].y = dstY0;
1807       verts[0].z = z;
1808       verts[0].s = 0.0F;
1809       verts[0].t = 0.0F;
1810       verts[1].x = dstX1;
1811       verts[1].y = dstY0;
1812       verts[1].z = z;
1813       verts[1].s = tex->Sright;
1814       verts[1].t = 0.0F;
1815       verts[2].x = dstX1;
1816       verts[2].y = dstY1;
1817       verts[2].z = z;
1818       verts[2].s = tex->Sright;
1819       verts[2].t = tex->Ttop;
1820       verts[3].x = dstX0;
1821       verts[3].y = dstY1;
1822       verts[3].z = z;
1823       verts[3].s = 0.0F;
1824       verts[3].t = tex->Ttop;
1825
1826       /* upload new vertex data */
1827       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
1828    }
1829
1830    /* Alloc/setup texture */
1831    setup_copypix_texture(tex, newTex, srcX, srcY, width, height,
1832                          GL_RGBA, GL_NEAREST);
1833
1834    _mesa_set_enable(ctx, tex->Target, GL_TRUE);
1835
1836    /* draw textured quad */
1837    _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
1838
1839    _mesa_set_enable(ctx, tex->Target, GL_FALSE);
1840
1841    _mesa_meta_end(ctx);
1842 }
1843
1844
1845
1846 /**
1847  * When the glDrawPixels() image size is greater than the max rectangle
1848  * texture size we use this function to break the glDrawPixels() image
1849  * into tiles which fit into the max texture size.
1850  */
1851 static void
1852 tiled_draw_pixels(struct gl_context *ctx,
1853                   GLint tileSize,
1854                   GLint x, GLint y, GLsizei width, GLsizei height,
1855                   GLenum format, GLenum type,
1856                   const struct gl_pixelstore_attrib *unpack,
1857                   const GLvoid *pixels)
1858 {
1859    struct gl_pixelstore_attrib tileUnpack = *unpack;
1860    GLint i, j;
1861
1862    if (tileUnpack.RowLength == 0)
1863       tileUnpack.RowLength = width;
1864
1865    for (i = 0; i < width; i += tileSize) {
1866       const GLint tileWidth = MIN2(tileSize, width - i);
1867       const GLint tileX = (GLint) (x + i * ctx->Pixel.ZoomX);
1868
1869       tileUnpack.SkipPixels = unpack->SkipPixels + i;
1870
1871       for (j = 0; j < height; j += tileSize) {
1872          const GLint tileHeight = MIN2(tileSize, height - j);
1873          const GLint tileY = (GLint) (y + j * ctx->Pixel.ZoomY);
1874
1875          tileUnpack.SkipRows = unpack->SkipRows + j;
1876
1877          _mesa_meta_DrawPixels(ctx, tileX, tileY, tileWidth, tileHeight,
1878                                format, type, &tileUnpack, pixels);
1879       }
1880    }
1881 }
1882
1883
1884 /**
1885  * One-time init for drawing stencil pixels.
1886  */
1887 static void
1888 init_draw_stencil_pixels(struct gl_context *ctx)
1889 {
1890    /* This program is run eight times, once for each stencil bit.
1891     * The stencil values to draw are found in an 8-bit alpha texture.
1892     * We read the texture/stencil value and test if bit 'b' is set.
1893     * If the bit is not set, use KIL to kill the fragment.
1894     * Finally, we use the stencil test to update the stencil buffer.
1895     *
1896     * The basic algorithm for checking if a bit is set is:
1897     *   if (is_odd(value / (1 << bit)))
1898     *      result is one (or non-zero).
1899     *   else
1900     *      result is zero.
1901     * The program parameter contains three values:
1902     *   parm.x = 255 / (1 << bit)
1903     *   parm.y = 0.5
1904     *   parm.z = 0.0
1905     */
1906    static const char *program =
1907       "!!ARBfp1.0\n"
1908       "PARAM parm = program.local[0]; \n"
1909       "TEMP t; \n"
1910       "TEX t, fragment.texcoord[0], texture[0], %s; \n"   /* NOTE %s here! */
1911       "# t = t * 255 / bit \n"
1912       "MUL t.x, t.a, parm.x; \n"
1913       "# t = (int) t \n"
1914       "FRC t.y, t.x; \n"
1915       "SUB t.x, t.x, t.y; \n"
1916       "# t = t * 0.5 \n"
1917       "MUL t.x, t.x, parm.y; \n"
1918       "# t = fract(t.x) \n"
1919       "FRC t.x, t.x; # if t.x != 0, then the bit is set \n"
1920       "# t.x = (t.x == 0 ? 1 : 0) \n"
1921       "SGE t.x, -t.x, parm.z; \n"
1922       "KIL -t.x; \n"
1923       "# for debug only \n"
1924       "#MOV result.color, t.x; \n"
1925       "END \n";
1926    char program2[1000];
1927    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1928    struct temp_texture *tex = get_temp_texture(ctx);
1929    const char *texTarget;
1930
1931    assert(drawpix->StencilFP == 0);
1932
1933    /* replace %s with "RECT" or "2D" */
1934    assert(strlen(program) + 4 < sizeof(program2));
1935    if (tex->Target == GL_TEXTURE_RECTANGLE)
1936       texTarget = "RECT";
1937    else
1938       texTarget = "2D";
1939    _mesa_snprintf(program2, sizeof(program2), program, texTarget);
1940
1941    _mesa_GenPrograms(1, &drawpix->StencilFP);
1942    _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
1943    _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
1944                           strlen(program2), (const GLubyte *) program2);
1945 }
1946
1947
1948 /**
1949  * One-time init for drawing depth pixels.
1950  */
1951 static void
1952 init_draw_depth_pixels(struct gl_context *ctx)
1953 {
1954    static const char *program =
1955       "!!ARBfp1.0\n"
1956       "PARAM color = program.local[0]; \n"
1957       "TEX result.depth, fragment.texcoord[0], texture[0], %s; \n"
1958       "MOV result.color, color; \n"
1959       "END \n";
1960    char program2[200];
1961    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1962    struct temp_texture *tex = get_temp_texture(ctx);
1963    const char *texTarget;
1964
1965    assert(drawpix->DepthFP == 0);
1966
1967    /* replace %s with "RECT" or "2D" */
1968    assert(strlen(program) + 4 < sizeof(program2));
1969    if (tex->Target == GL_TEXTURE_RECTANGLE)
1970       texTarget = "RECT";
1971    else
1972       texTarget = "2D";
1973    _mesa_snprintf(program2, sizeof(program2), program, texTarget);
1974
1975    _mesa_GenPrograms(1, &drawpix->DepthFP);
1976    _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
1977    _mesa_ProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
1978                           strlen(program2), (const GLubyte *) program2);
1979 }
1980
1981
1982 /**
1983  * Meta implementation of ctx->Driver.DrawPixels() in terms
1984  * of texture mapping and polygon rendering.
1985  */
1986 void
1987 _mesa_meta_DrawPixels(struct gl_context *ctx,
1988                       GLint x, GLint y, GLsizei width, GLsizei height,
1989                       GLenum format, GLenum type,
1990                       const struct gl_pixelstore_attrib *unpack,
1991                       const GLvoid *pixels)
1992 {
1993    struct drawpix_state *drawpix = &ctx->Meta->DrawPix;
1994    struct temp_texture *tex = get_temp_texture(ctx);
1995    const struct gl_pixelstore_attrib unpackSave = ctx->Unpack;
1996    const GLuint origStencilMask = ctx->Stencil.WriteMask[0];
1997    struct vertex {
1998       GLfloat x, y, z, s, t;
1999    };
2000    struct vertex verts[4];
2001    GLenum texIntFormat;
2002    GLboolean fallback, newTex;
2003    GLbitfield metaExtraSave = 0x0;
2004    GLuint vbo;
2005
2006    /*
2007     * Determine if we can do the glDrawPixels with texture mapping.
2008     */
2009    fallback = GL_FALSE;
2010    if (ctx->_ImageTransferState ||
2011        ctx->Fog.Enabled) {
2012       fallback = GL_TRUE;
2013    }
2014
2015    if (_mesa_is_color_format(format)) {
2016       /* use more compact format when possible */
2017       /* XXX disable special case for GL_LUMINANCE for now to work around
2018        * apparent i965 driver bug (see bug #23670).
2019        */
2020       if (/*format == GL_LUMINANCE ||*/ format == GL_LUMINANCE_ALPHA)
2021          texIntFormat = format;
2022       else
2023          texIntFormat = GL_RGBA;
2024
2025       /* If we're not supposed to clamp the resulting color, then just
2026        * promote our texture to fully float.  We could do better by
2027        * just going for the matching set of channels, in floating
2028        * point.
2029        */
2030       if (ctx->Color.ClampFragmentColor != GL_TRUE &&
2031           ctx->Extensions.ARB_texture_float)
2032          texIntFormat = GL_RGBA32F;
2033    }
2034    else if (_mesa_is_stencil_format(format)) {
2035       if (ctx->Extensions.ARB_fragment_program &&
2036           ctx->Pixel.IndexShift == 0 &&
2037           ctx->Pixel.IndexOffset == 0 &&
2038           type == GL_UNSIGNED_BYTE) {
2039          /* We'll store stencil as alpha.  This only works for GLubyte
2040           * image data because of how incoming values are mapped to alpha
2041           * in [0,1].
2042           */
2043          texIntFormat = GL_ALPHA;
2044          metaExtraSave = (MESA_META_COLOR_MASK |
2045                           MESA_META_DEPTH_TEST |
2046                           MESA_META_SHADER |
2047                           MESA_META_STENCIL_TEST);
2048       }
2049       else {
2050          fallback = GL_TRUE;
2051       }
2052    }
2053    else if (_mesa_is_depth_format(format)) {
2054       if (ctx->Extensions.ARB_depth_texture &&
2055           ctx->Extensions.ARB_fragment_program) {
2056          texIntFormat = GL_DEPTH_COMPONENT;
2057          metaExtraSave = (MESA_META_SHADER);
2058       }
2059       else {
2060          fallback = GL_TRUE;
2061       }
2062    }
2063    else {
2064       fallback = GL_TRUE;
2065    }
2066
2067    if (fallback) {
2068       _swrast_DrawPixels(ctx, x, y, width, height,
2069                          format, type, unpack, pixels);
2070       return;
2071    }
2072
2073    /*
2074     * Check image size against max texture size, draw as tiles if needed.
2075     */
2076    if (width > tex->MaxSize || height > tex->MaxSize) {
2077       tiled_draw_pixels(ctx, tex->MaxSize, x, y, width, height,
2078                         format, type, unpack, pixels);
2079       return;
2080    }
2081
2082    /* Most GL state applies to glDrawPixels (like blending, stencil, etc),
2083     * but a there's a few things we need to override:
2084     */
2085    _mesa_meta_begin(ctx, (MESA_META_RASTERIZATION |
2086                           MESA_META_SHADER |
2087                           MESA_META_TEXTURE |
2088                           MESA_META_TRANSFORM |
2089                           MESA_META_CLIP |
2090                           MESA_META_VERTEX |
2091                           MESA_META_VIEWPORT |
2092                           MESA_META_CLAMP_FRAGMENT_COLOR |
2093                           metaExtraSave));
2094
2095    newTex = alloc_texture(tex, width, height, texIntFormat);
2096
2097    /* vertex positions, texcoords (after texture allocation!) */
2098    {
2099       const GLfloat x0 = (GLfloat) x;
2100       const GLfloat y0 = (GLfloat) y;
2101       const GLfloat x1 = x + width * ctx->Pixel.ZoomX;
2102       const GLfloat y1 = y + height * ctx->Pixel.ZoomY;
2103       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
2104
2105       verts[0].x = x0;
2106       verts[0].y = y0;
2107       verts[0].z = z;
2108       verts[0].s = 0.0F;
2109       verts[0].t = 0.0F;
2110       verts[1].x = x1;
2111       verts[1].y = y0;
2112       verts[1].z = z;
2113       verts[1].s = tex->Sright;
2114       verts[1].t = 0.0F;
2115       verts[2].x = x1;
2116       verts[2].y = y1;
2117       verts[2].z = z;
2118       verts[2].s = tex->Sright;
2119       verts[2].t = tex->Ttop;
2120       verts[3].x = x0;
2121       verts[3].y = y1;
2122       verts[3].z = z;
2123       verts[3].s = 0.0F;
2124       verts[3].t = tex->Ttop;
2125    }
2126
2127    if (drawpix->ArrayObj == 0) {
2128       /* one-time setup: create vertex array object */
2129       _mesa_GenVertexArrays(1, &drawpix->ArrayObj);
2130    }
2131    _mesa_BindVertexArray(drawpix->ArrayObj);
2132
2133    /* create vertex array buffer */
2134    _mesa_GenBuffersARB(1, &vbo);
2135    _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
2136    _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
2137                        verts, GL_DYNAMIC_DRAW_ARB);
2138
2139    /* setup vertex arrays */
2140    _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
2141    _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
2142    _mesa_EnableClientState(GL_VERTEX_ARRAY);
2143    _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
2144
2145    /* set given unpack params */
2146    ctx->Unpack = *unpack;
2147
2148    _mesa_set_enable(ctx, tex->Target, GL_TRUE);
2149
2150    if (_mesa_is_stencil_format(format)) {
2151       /* Drawing stencil */
2152       GLint bit;
2153
2154       if (!drawpix->StencilFP)
2155          init_draw_stencil_pixels(ctx);
2156
2157       setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
2158                             GL_ALPHA, type, pixels);
2159
2160       _mesa_ColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
2161
2162       _mesa_set_enable(ctx, GL_STENCIL_TEST, GL_TRUE);
2163
2164       /* set all stencil bits to 0 */
2165       _mesa_StencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
2166       _mesa_StencilFunc(GL_ALWAYS, 0, 255);
2167       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2168
2169       /* set stencil bits to 1 where needed */
2170       _mesa_StencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
2171
2172       _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->StencilFP);
2173       _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
2174
2175       for (bit = 0; bit < ctx->DrawBuffer->Visual.stencilBits; bit++) {
2176          const GLuint mask = 1 << bit;
2177          if (mask & origStencilMask) {
2178             _mesa_StencilFunc(GL_ALWAYS, mask, mask);
2179             _mesa_StencilMask(mask);
2180
2181             _mesa_ProgramLocalParameter4fARB(GL_FRAGMENT_PROGRAM_ARB, 0,
2182                                              255.0 / mask, 0.5, 0.0, 0.0);
2183
2184             _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2185          }
2186       }
2187    }
2188    else if (_mesa_is_depth_format(format)) {
2189       /* Drawing depth */
2190       if (!drawpix->DepthFP)
2191          init_draw_depth_pixels(ctx);
2192
2193       _mesa_BindProgram(GL_FRAGMENT_PROGRAM_ARB, drawpix->DepthFP);
2194       _mesa_set_enable(ctx, GL_FRAGMENT_PROGRAM_ARB, GL_TRUE);
2195
2196       /* polygon color = current raster color */
2197       _mesa_ProgramLocalParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0,
2198                                         ctx->Current.RasterColor);
2199
2200       setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
2201                             format, type, pixels);
2202
2203       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2204    }
2205    else {
2206       /* Drawing RGBA */
2207       setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
2208                             format, type, pixels);
2209       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2210    }
2211
2212    _mesa_set_enable(ctx, tex->Target, GL_FALSE);
2213
2214    _mesa_DeleteBuffersARB(1, &vbo);
2215
2216    /* restore unpack params */
2217    ctx->Unpack = unpackSave;
2218
2219    _mesa_meta_end(ctx);
2220 }
2221
2222 static GLboolean
2223 alpha_test_raster_color(struct gl_context *ctx)
2224 {
2225    GLfloat alpha = ctx->Current.RasterColor[ACOMP];
2226    GLfloat ref = ctx->Color.AlphaRef;
2227
2228    switch (ctx->Color.AlphaFunc) {
2229       case GL_NEVER:
2230          return GL_FALSE;
2231       case GL_LESS:
2232          return alpha < ref;
2233       case GL_EQUAL:
2234          return alpha == ref;
2235       case GL_LEQUAL:
2236          return alpha <= ref;
2237       case GL_GREATER:
2238          return alpha > ref;
2239       case GL_NOTEQUAL:
2240          return alpha != ref;
2241       case GL_GEQUAL:
2242          return alpha >= ref;
2243       case GL_ALWAYS:
2244          return GL_TRUE;
2245       default:
2246          assert(0);
2247          return GL_FALSE;
2248    }
2249 }
2250
2251 /**
2252  * Do glBitmap with a alpha texture quad.  Use the alpha test to cull
2253  * the 'off' bits.  A bitmap cache as in the gallium/mesa state
2254  * tracker would improve performance a lot.
2255  */
2256 void
2257 _mesa_meta_Bitmap(struct gl_context *ctx,
2258                   GLint x, GLint y, GLsizei width, GLsizei height,
2259                   const struct gl_pixelstore_attrib *unpack,
2260                   const GLubyte *bitmap1)
2261 {
2262    struct bitmap_state *bitmap = &ctx->Meta->Bitmap;
2263    struct temp_texture *tex = get_bitmap_temp_texture(ctx);
2264    const GLenum texIntFormat = GL_ALPHA;
2265    const struct gl_pixelstore_attrib unpackSave = *unpack;
2266    GLubyte fg, bg;
2267    struct vertex {
2268       GLfloat x, y, z, s, t, r, g, b, a;
2269    };
2270    struct vertex verts[4];
2271    GLboolean newTex;
2272    GLubyte *bitmap8;
2273
2274    /*
2275     * Check if swrast fallback is needed.
2276     */
2277    if (ctx->_ImageTransferState ||
2278        ctx->FragmentProgram._Enabled ||
2279        ctx->Fog.Enabled ||
2280        ctx->Texture._EnabledUnits ||
2281        width > tex->MaxSize ||
2282        height > tex->MaxSize) {
2283       _swrast_Bitmap(ctx, x, y, width, height, unpack, bitmap1);
2284       return;
2285    }
2286
2287    if (ctx->Color.AlphaEnabled && !alpha_test_raster_color(ctx))
2288       return;
2289
2290    /* Most GL state applies to glBitmap (like blending, stencil, etc),
2291     * but a there's a few things we need to override:
2292     */
2293    _mesa_meta_begin(ctx, (MESA_META_ALPHA_TEST |
2294                           MESA_META_PIXEL_STORE |
2295                           MESA_META_RASTERIZATION |
2296                           MESA_META_SHADER |
2297                           MESA_META_TEXTURE |
2298                           MESA_META_TRANSFORM |
2299                           MESA_META_CLIP |
2300                           MESA_META_VERTEX |
2301                           MESA_META_VIEWPORT));
2302
2303    if (bitmap->ArrayObj == 0) {
2304       /* one-time setup */
2305
2306       /* create vertex array object */
2307       _mesa_GenVertexArraysAPPLE(1, &bitmap->ArrayObj);
2308       _mesa_BindVertexArrayAPPLE(bitmap->ArrayObj);
2309
2310       /* create vertex array buffer */
2311       _mesa_GenBuffersARB(1, &bitmap->VBO);
2312       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
2313       _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
2314                           NULL, GL_DYNAMIC_DRAW_ARB);
2315
2316       /* setup vertex arrays */
2317       _mesa_VertexPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
2318       _mesa_TexCoordPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
2319       _mesa_ColorPointer(4, GL_FLOAT, sizeof(struct vertex), OFFSET(r));
2320       _mesa_EnableClientState(GL_VERTEX_ARRAY);
2321       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
2322       _mesa_EnableClientState(GL_COLOR_ARRAY);
2323    }
2324    else {
2325       _mesa_BindVertexArray(bitmap->ArrayObj);
2326       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, bitmap->VBO);
2327    }
2328
2329    newTex = alloc_texture(tex, width, height, texIntFormat);
2330
2331    /* vertex positions, texcoords, colors (after texture allocation!) */
2332    {
2333       const GLfloat x0 = (GLfloat) x;
2334       const GLfloat y0 = (GLfloat) y;
2335       const GLfloat x1 = (GLfloat) (x + width);
2336       const GLfloat y1 = (GLfloat) (y + height);
2337       const GLfloat z = invert_z(ctx->Current.RasterPos[2]);
2338       GLuint i;
2339
2340       verts[0].x = x0;
2341       verts[0].y = y0;
2342       verts[0].z = z;
2343       verts[0].s = 0.0F;
2344       verts[0].t = 0.0F;
2345       verts[1].x = x1;
2346       verts[1].y = y0;
2347       verts[1].z = z;
2348       verts[1].s = tex->Sright;
2349       verts[1].t = 0.0F;
2350       verts[2].x = x1;
2351       verts[2].y = y1;
2352       verts[2].z = z;
2353       verts[2].s = tex->Sright;
2354       verts[2].t = tex->Ttop;
2355       verts[3].x = x0;
2356       verts[3].y = y1;
2357       verts[3].z = z;
2358       verts[3].s = 0.0F;
2359       verts[3].t = tex->Ttop;
2360
2361       for (i = 0; i < 4; i++) {
2362          verts[i].r = ctx->Current.RasterColor[0];
2363          verts[i].g = ctx->Current.RasterColor[1];
2364          verts[i].b = ctx->Current.RasterColor[2];
2365          verts[i].a = ctx->Current.RasterColor[3];
2366       }
2367
2368       /* upload new vertex data */
2369       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
2370    }
2371
2372    /* choose different foreground/background alpha values */
2373    CLAMPED_FLOAT_TO_UBYTE(fg, ctx->Current.RasterColor[ACOMP]);
2374    bg = (fg > 127 ? 0 : 255);
2375
2376    bitmap1 = _mesa_map_pbo_source(ctx, &unpackSave, bitmap1);
2377    if (!bitmap1) {
2378       _mesa_meta_end(ctx);
2379       return;
2380    }
2381
2382    bitmap8 = (GLubyte *) malloc(width * height);
2383    if (bitmap8) {
2384       memset(bitmap8, bg, width * height);
2385       _mesa_expand_bitmap(width, height, &unpackSave, bitmap1,
2386                           bitmap8, width, fg);
2387
2388       _mesa_set_enable(ctx, tex->Target, GL_TRUE);
2389
2390       _mesa_set_enable(ctx, GL_ALPHA_TEST, GL_TRUE);
2391       _mesa_AlphaFunc(GL_NOTEQUAL, UBYTE_TO_FLOAT(bg));
2392
2393       setup_drawpix_texture(ctx, tex, newTex, texIntFormat, width, height,
2394                             GL_ALPHA, GL_UNSIGNED_BYTE, bitmap8);
2395
2396       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2397
2398       _mesa_set_enable(ctx, tex->Target, GL_FALSE);
2399
2400       free(bitmap8);
2401    }
2402
2403    _mesa_unmap_pbo_source(ctx, &unpackSave);
2404
2405    _mesa_meta_end(ctx);
2406 }
2407
2408
2409 /**
2410  * Check if the call to _mesa_meta_GenerateMipmap() will require a
2411  * software fallback.  The fallback path will require that the texture
2412  * images are mapped.
2413  * \return GL_TRUE if a fallback is needed, GL_FALSE otherwise
2414  */
2415 GLboolean
2416 _mesa_meta_check_generate_mipmap_fallback(struct gl_context *ctx, GLenum target,
2417                                           struct gl_texture_object *texObj)
2418 {
2419    const GLuint fboSave = ctx->DrawBuffer->Name;
2420    struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
2421    struct gl_texture_image *baseImage;
2422    GLuint srcLevel;
2423    GLenum status;
2424
2425    /* check for fallbacks */
2426    if (!ctx->Extensions.EXT_framebuffer_object ||
2427        target == GL_TEXTURE_3D) {
2428       return GL_TRUE;
2429    }
2430
2431    srcLevel = texObj->BaseLevel;
2432    baseImage = _mesa_select_tex_image(ctx, texObj, target, srcLevel);
2433    if (!baseImage || _mesa_is_format_compressed(baseImage->TexFormat)) {
2434       return GL_TRUE;
2435    }
2436
2437    /*
2438     * Test that we can actually render in the texture's format.
2439     */
2440    if (!mipmap->FBO)
2441       _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
2442    _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
2443
2444    if (target == GL_TEXTURE_1D) {
2445       _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
2446                                     GL_COLOR_ATTACHMENT0_EXT,
2447                                     target, texObj->Name, srcLevel);
2448    }
2449 #if 0
2450    /* other work is needed to enable 3D mipmap generation */
2451    else if (target == GL_TEXTURE_3D) {
2452       GLint zoffset = 0;
2453       _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,
2454                                     GL_COLOR_ATTACHMENT0_EXT,
2455                                     target, texObj->Name, srcLevel, zoffset);
2456    }
2457 #endif
2458    else {
2459       /* 2D / cube */
2460       _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
2461                                     GL_COLOR_ATTACHMENT0_EXT,
2462                                     target, texObj->Name, srcLevel);
2463    }
2464
2465    status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
2466
2467    _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
2468
2469    if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
2470       return GL_TRUE;
2471    }
2472
2473    return GL_FALSE;
2474 }
2475
2476
2477 /**
2478  * Called via ctx->Driver.GenerateMipmap()
2479  * Note: texture borders and 3D texture support not yet complete.
2480  */
2481 void
2482 _mesa_meta_GenerateMipmap(struct gl_context *ctx, GLenum target,
2483                           struct gl_texture_object *texObj)
2484 {
2485    struct gen_mipmap_state *mipmap = &ctx->Meta->Mipmap;
2486    struct vertex {
2487       GLfloat x, y, s, t, r;
2488    };
2489    struct vertex verts[4];
2490    const GLuint baseLevel = texObj->BaseLevel;
2491    const GLuint maxLevel = texObj->MaxLevel;
2492    const GLenum minFilterSave = texObj->Sampler.MinFilter;
2493    const GLenum magFilterSave = texObj->Sampler.MagFilter;
2494    const GLint maxLevelSave = texObj->MaxLevel;
2495    const GLboolean genMipmapSave = texObj->GenerateMipmap;
2496    const GLenum wrapSSave = texObj->Sampler.WrapS;
2497    const GLenum wrapTSave = texObj->Sampler.WrapT;
2498    const GLenum wrapRSave = texObj->Sampler.WrapR;
2499    const GLuint fboSave = ctx->DrawBuffer->Name;
2500    const GLuint original_active_unit = ctx->Texture.CurrentUnit;
2501    GLenum faceTarget;
2502    GLuint dstLevel;
2503    GLuint border = 0;
2504
2505    if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) {
2506       _mesa_generate_mipmap(ctx, target, texObj);
2507       return;
2508    }
2509
2510    if (target >= GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
2511        target <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) {
2512       faceTarget = target;
2513       target = GL_TEXTURE_CUBE_MAP;
2514    }
2515    else {
2516       faceTarget = target;
2517    }
2518
2519    _mesa_meta_begin(ctx, MESA_META_ALL);
2520
2521    if (original_active_unit != 0)
2522       _mesa_BindTexture(target, texObj->Name);
2523
2524    if (mipmap->ArrayObj == 0) {
2525       /* one-time setup */
2526
2527       /* create vertex array object */
2528       _mesa_GenVertexArraysAPPLE(1, &mipmap->ArrayObj);
2529       _mesa_BindVertexArrayAPPLE(mipmap->ArrayObj);
2530
2531       /* create vertex array buffer */
2532       _mesa_GenBuffersARB(1, &mipmap->VBO);
2533       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
2534       _mesa_BufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(verts),
2535                           NULL, GL_DYNAMIC_DRAW_ARB);
2536
2537       /* setup vertex arrays */
2538       _mesa_VertexPointer(2, GL_FLOAT, sizeof(struct vertex), OFFSET(x));
2539       _mesa_TexCoordPointer(3, GL_FLOAT, sizeof(struct vertex), OFFSET(s));
2540       _mesa_EnableClientState(GL_VERTEX_ARRAY);
2541       _mesa_EnableClientState(GL_TEXTURE_COORD_ARRAY);
2542    }
2543    else {
2544       _mesa_BindVertexArray(mipmap->ArrayObj);
2545       _mesa_BindBufferARB(GL_ARRAY_BUFFER_ARB, mipmap->VBO);
2546    }
2547
2548    if (!mipmap->FBO) {
2549       _mesa_GenFramebuffersEXT(1, &mipmap->FBO);
2550    }
2551    _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, mipmap->FBO);
2552
2553    _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
2554    _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
2555    _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, GL_FALSE);
2556    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2557    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2558    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
2559
2560    _mesa_set_enable(ctx, target, GL_TRUE);
2561
2562    /* setup texcoords once (XXX what about border?) */
2563    switch (faceTarget) {
2564    case GL_TEXTURE_1D:
2565    case GL_TEXTURE_2D:
2566       verts[0].s = 0.0F;
2567       verts[0].t = 0.0F;
2568       verts[0].r = 0.0F;
2569       verts[1].s = 1.0F;
2570       verts[1].t = 0.0F;
2571       verts[1].r = 0.0F;
2572       verts[2].s = 1.0F;
2573       verts[2].t = 1.0F;
2574       verts[2].r = 0.0F;
2575       verts[3].s = 0.0F;
2576       verts[3].t = 1.0F;
2577       verts[3].r = 0.0F;
2578       break;
2579    case GL_TEXTURE_3D:
2580       abort();
2581       break;
2582    default:
2583       /* cube face */
2584       {
2585          static const GLfloat st[4][2] = {
2586             {0.0f, 0.0f}, {1.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f}
2587          };
2588          GLuint i;
2589
2590          /* loop over quad verts */
2591          for (i = 0; i < 4; i++) {
2592             /* Compute sc = +/-scale and tc = +/-scale.
2593              * Not +/-1 to avoid cube face selection ambiguity near the edges,
2594              * though that can still sometimes happen with this scale factor...
2595              */
2596             const GLfloat scale = 0.9999f;
2597             const GLfloat sc = (2.0f * st[i][0] - 1.0f) * scale;
2598             const GLfloat tc = (2.0f * st[i][1] - 1.0f) * scale;
2599
2600             switch (faceTarget) {
2601             case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
2602                verts[i].s = 1.0f;
2603                verts[i].t = -tc;
2604                verts[i].r = -sc;
2605                break;
2606             case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
2607                verts[i].s = -1.0f;
2608                verts[i].t = -tc;
2609                verts[i].r = sc;
2610                break;
2611             case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
2612                verts[i].s = sc;
2613                verts[i].t = 1.0f;
2614                verts[i].r = tc;
2615                break;
2616             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
2617                verts[i].s = sc;
2618                verts[i].t = -1.0f;
2619                verts[i].r = -tc;
2620                break;
2621             case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
2622                verts[i].s = sc;
2623                verts[i].t = -tc;
2624                verts[i].r = 1.0f;
2625                break;
2626             case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
2627                verts[i].s = -sc;
2628                verts[i].t = -tc;
2629                verts[i].r = -1.0f;
2630                break;
2631             default:
2632                assert(0);
2633             }
2634          }
2635       }
2636    }
2637
2638    _mesa_set_enable(ctx, target, GL_TRUE);
2639
2640    /* setup vertex positions */
2641    {
2642       verts[0].x = 0.0F;
2643       verts[0].y = 0.0F;
2644       verts[1].x = 1.0F;
2645       verts[1].y = 0.0F;
2646       verts[2].x = 1.0F;
2647       verts[2].y = 1.0F;
2648       verts[3].x = 0.0F;
2649       verts[3].y = 1.0F;
2650
2651       /* upload new vertex data */
2652       _mesa_BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(verts), verts);
2653    }
2654
2655    /* setup projection matrix */
2656    _mesa_MatrixMode(GL_PROJECTION);
2657    _mesa_LoadIdentity();
2658    _mesa_Ortho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
2659
2660    /* texture is already locked, unlock now */
2661    _mesa_unlock_texture(ctx, texObj);
2662
2663    for (dstLevel = baseLevel + 1; dstLevel <= maxLevel; dstLevel++) {
2664       const struct gl_texture_image *srcImage;
2665       const GLuint srcLevel = dstLevel - 1;
2666       GLsizei srcWidth, srcHeight, srcDepth;
2667       GLsizei dstWidth, dstHeight, dstDepth;
2668       GLenum status;
2669
2670       srcImage = _mesa_select_tex_image(ctx, texObj, faceTarget, srcLevel);
2671       assert(srcImage->Border == 0); /* XXX we can fix this */
2672
2673       /* src size w/out border */
2674       srcWidth = srcImage->Width - 2 * border;
2675       srcHeight = srcImage->Height - 2 * border;
2676       srcDepth = srcImage->Depth - 2 * border;
2677
2678       /* new dst size w/ border */
2679       dstWidth = MAX2(1, srcWidth / 2) + 2 * border;
2680       dstHeight = MAX2(1, srcHeight / 2) + 2 * border;
2681       dstDepth = MAX2(1, srcDepth / 2) + 2 * border;
2682
2683       if (dstWidth == srcImage->Width &&
2684           dstHeight == srcImage->Height &&
2685           dstDepth == srcImage->Depth) {
2686          /* all done */
2687          break;
2688       }
2689
2690       /* Set MaxLevel large enough to hold the new level when we allocate it  */
2691       _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, dstLevel);
2692
2693       /* Create empty dest image */
2694       if (target == GL_TEXTURE_1D) {
2695          _mesa_TexImage1D(target, dstLevel, srcImage->InternalFormat,
2696                           dstWidth, border,
2697                           GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2698       }
2699       else if (target == GL_TEXTURE_3D) {
2700          _mesa_TexImage3D(target, dstLevel, srcImage->InternalFormat,
2701                           dstWidth, dstHeight, dstDepth, border,
2702                           GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2703       }
2704       else {
2705          /* 2D or cube */
2706          _mesa_TexImage2D(faceTarget, dstLevel, srcImage->InternalFormat,
2707                           dstWidth, dstHeight, border,
2708                           GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2709
2710          if (target == GL_TEXTURE_CUBE_MAP) {
2711             /* If texturing from a cube, we need to make sure all src faces
2712              * have been defined (even if we're not sampling from them.)
2713              * Otherwise the texture object will be 'incomplete' and
2714              * texturing from it will not be allowed.
2715              */
2716             GLuint face;
2717             for (face = 0; face < 6; face++) {
2718                if (!texObj->Image[face][srcLevel] ||
2719                    texObj->Image[face][srcLevel]->Width != srcWidth) {
2720                   _mesa_TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,
2721                                    srcLevel, srcImage->InternalFormat,
2722                                    srcWidth, srcHeight, border,
2723                                    GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2724                }
2725             }
2726          }
2727       }
2728
2729       /* limit minification to src level */
2730       _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, srcLevel);
2731
2732       /* Set to draw into the current dstLevel */
2733       if (target == GL_TEXTURE_1D) {
2734          _mesa_FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT,
2735                                        GL_COLOR_ATTACHMENT0_EXT,
2736                                        target,
2737                                        texObj->Name,
2738                                        dstLevel);
2739       }
2740       else if (target == GL_TEXTURE_3D) {
2741          GLint zoffset = 0; /* XXX unfinished */
2742          _mesa_FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT,
2743                                        GL_COLOR_ATTACHMENT0_EXT,
2744                                        target,
2745                                        texObj->Name,
2746                                        dstLevel, zoffset);
2747       }
2748       else {
2749          /* 2D / cube */
2750          _mesa_FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
2751                                        GL_COLOR_ATTACHMENT0_EXT,
2752                                        faceTarget,
2753                                        texObj->Name,
2754                                        dstLevel);
2755       }
2756
2757       _mesa_DrawBuffer(GL_COLOR_ATTACHMENT0_EXT);
2758
2759       /* sanity check */
2760       status = _mesa_CheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
2761       if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
2762          abort();
2763          break;
2764       }
2765
2766       assert(dstWidth == ctx->DrawBuffer->Width);
2767       assert(dstHeight == ctx->DrawBuffer->Height);
2768
2769       /* setup viewport */
2770       _mesa_set_viewport(ctx, 0, 0, dstWidth, dstHeight);
2771
2772       _mesa_DrawArrays(GL_TRIANGLE_FAN, 0, 4);
2773    }
2774
2775    _mesa_lock_texture(ctx, texObj); /* relock */
2776
2777    _mesa_meta_end(ctx);
2778
2779    _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilterSave);
2780    _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilterSave);
2781    _mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, maxLevelSave);
2782    _mesa_TexParameteri(target, GL_GENERATE_MIPMAP, genMipmapSave);
2783    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, wrapSSave);
2784    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, wrapTSave);
2785    _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, wrapRSave);
2786
2787    _mesa_BindFramebufferEXT(GL_FRAMEBUFFER_EXT, fboSave);
2788 }
2789
2790
2791 /**
2792  * Determine the GL data type to use for the temporary image read with
2793  * ReadPixels() and passed to Tex[Sub]Image().
2794  */
2795 static GLenum
2796 get_temp_image_type(struct gl_context *ctx, GLenum baseFormat)
2797 {
2798    switch (baseFormat) {
2799    case GL_RGBA:
2800    case GL_RGB:
2801    case GL_ALPHA:
2802    case GL_LUMINANCE:
2803    case GL_LUMINANCE_ALPHA:
2804    case GL_INTENSITY:
2805       if (ctx->DrawBuffer->Visual.redBits <= 8)
2806          return GL_UNSIGNED_BYTE;
2807       else if (ctx->DrawBuffer->Visual.redBits <= 8)
2808          return GL_UNSIGNED_SHORT;
2809       else
2810          return GL_FLOAT;
2811    case GL_DEPTH_COMPONENT:
2812       return GL_UNSIGNED_INT;
2813    case GL_DEPTH_STENCIL:
2814       return GL_UNSIGNED_INT_24_8;
2815    default:
2816       _mesa_problem(ctx, "Unexpected format in get_temp_image_type()");
2817       return 0;
2818    }
2819 }
2820
2821
2822 /**
2823  * Helper for _mesa_meta_CopyTexSubImage1/2/3D() functions.
2824  * Have to be careful with locking and meta state for pixel transfer.
2825  */
2826 static void
2827 copy_tex_sub_image(struct gl_context *ctx,
2828                    GLuint dims, GLenum target, GLint level,
2829                    GLint xoffset, GLint yoffset, GLint zoffset,
2830                    GLint x, GLint y,
2831                    GLsizei width, GLsizei height)
2832 {
2833    struct gl_texture_object *texObj;
2834    struct gl_texture_image *texImage;
2835    GLenum format, type;
2836    GLint bpp;
2837    void *buf;
2838
2839    texObj = _mesa_get_current_tex_object(ctx, target);
2840    texImage = _mesa_select_tex_image(ctx, texObj, target, level);
2841
2842    /* Choose format/type for temporary image buffer */
2843    format = _mesa_get_format_base_format(texImage->TexFormat);
2844    if (format == GL_LUMINANCE ||
2845        format == GL_LUMINANCE_ALPHA ||
2846        format == GL_INTENSITY) {
2847       /* We don't want to use GL_LUMINANCE, GL_INTENSITY, etc. for the
2848        * temp image buffer because glReadPixels will do L=R+G+B which is
2849        * not what we want (should be L=R).
2850        */
2851       format = GL_RGBA;
2852    }
2853
2854    type = get_temp_image_type(ctx, format);
2855    bpp = _mesa_bytes_per_pixel(format, type);
2856    if (bpp <= 0) {
2857       _mesa_problem(ctx, "Bad bpp in meta copy_tex_sub_image()");
2858       return;
2859    }
2860
2861    /*
2862     * Alloc image buffer (XXX could use a PBO)
2863     */
2864    buf = malloc(width * height * bpp);
2865    if (!buf) {
2866       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage%uD", dims);
2867       return;
2868    }
2869
2870    _mesa_unlock_texture(ctx, texObj); /* need to unlock first */
2871
2872    /*
2873     * Read image from framebuffer (disable pixel transfer ops)
2874     */
2875    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE | MESA_META_PIXEL_TRANSFER);
2876    ctx->Driver.ReadPixels(ctx, x, y, width, height,
2877                           format, type, &ctx->Pack, buf);
2878    _mesa_meta_end(ctx);
2879
2880    _mesa_update_state(ctx); /* to update pixel transfer state */
2881
2882    /*
2883     * Store texture data (with pixel transfer ops)
2884     */
2885    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE);
2886    if (target == GL_TEXTURE_1D) {
2887       ctx->Driver.TexSubImage1D(ctx, target, level, xoffset,
2888                                 width, format, type, buf,
2889                                 &ctx->Unpack, texObj, texImage);
2890    }
2891    else if (target == GL_TEXTURE_3D) {
2892       ctx->Driver.TexSubImage3D(ctx, target, level, xoffset, yoffset, zoffset,
2893                                 width, height, 1, format, type, buf,
2894                                 &ctx->Unpack, texObj, texImage);
2895    }
2896    else {
2897       ctx->Driver.TexSubImage2D(ctx, target, level, xoffset, yoffset,
2898                                 width, height, format, type, buf,
2899                                 &ctx->Unpack, texObj, texImage);
2900    }
2901    _mesa_meta_end(ctx);
2902
2903    _mesa_lock_texture(ctx, texObj); /* re-lock */
2904
2905    free(buf);
2906 }
2907
2908
2909 void
2910 _mesa_meta_CopyTexSubImage1D(struct gl_context *ctx, GLenum target, GLint level,
2911                              GLint xoffset,
2912                              GLint x, GLint y, GLsizei width)
2913 {
2914    copy_tex_sub_image(ctx, 1, target, level, xoffset, 0, 0,
2915                       x, y, width, 1);
2916 }
2917
2918
2919 void
2920 _mesa_meta_CopyTexSubImage2D(struct gl_context *ctx, GLenum target, GLint level,
2921                              GLint xoffset, GLint yoffset,
2922                              GLint x, GLint y,
2923                              GLsizei width, GLsizei height)
2924 {
2925    copy_tex_sub_image(ctx, 2, target, level, xoffset, yoffset, 0,
2926                       x, y, width, height);
2927 }
2928
2929
2930 void
2931 _mesa_meta_CopyTexSubImage3D(struct gl_context *ctx, GLenum target, GLint level,
2932                              GLint xoffset, GLint yoffset, GLint zoffset,
2933                              GLint x, GLint y,
2934                              GLsizei width, GLsizei height)
2935 {
2936    copy_tex_sub_image(ctx, 3, target, level, xoffset, yoffset, zoffset,
2937                       x, y, width, height);
2938 }
2939
2940
2941 void
2942 _mesa_meta_CopyColorTable(struct gl_context *ctx,
2943                           GLenum target, GLenum internalformat,
2944                           GLint x, GLint y, GLsizei width)
2945 {
2946    GLfloat *buf;
2947
2948    buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
2949    if (!buf) {
2950       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorTable");
2951       return;
2952    }
2953
2954    /*
2955     * Read image from framebuffer (disable pixel transfer ops)
2956     */
2957    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE | MESA_META_PIXEL_TRANSFER);
2958    ctx->Driver.ReadPixels(ctx, x, y, width, 1,
2959                           GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
2960
2961    _mesa_ColorTable(target, internalformat, width, GL_RGBA, GL_FLOAT, buf);
2962
2963    _mesa_meta_end(ctx);
2964
2965    free(buf);
2966 }
2967
2968
2969 void
2970 _mesa_meta_CopyColorSubTable(struct gl_context *ctx,GLenum target, GLsizei start,
2971                              GLint x, GLint y, GLsizei width)
2972 {
2973    GLfloat *buf;
2974
2975    buf = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
2976    if (!buf) {
2977       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyColorSubTable");
2978       return;
2979    }
2980
2981    /*
2982     * Read image from framebuffer (disable pixel transfer ops)
2983     */
2984    _mesa_meta_begin(ctx, MESA_META_PIXEL_STORE | MESA_META_PIXEL_TRANSFER);
2985    ctx->Driver.ReadPixels(ctx, x, y, width, 1,
2986                           GL_RGBA, GL_FLOAT, &ctx->Pack, buf);
2987
2988    _mesa_ColorSubTable(target, start, width, GL_RGBA, GL_FLOAT, buf);
2989
2990    _mesa_meta_end(ctx);
2991
2992    free(buf);
2993 }