Synchronised line endinge with release branch

10 files changed, 8270 insertions, 8270 deletions

diff --git a/mesalib/src/mesa/drivers/common/driverfuncs.c b/mesalib/src/mesa/drivers/common/driverfuncs.c
index 63df03f5d..36ed4f892 100644
--- a/mesalib/src/mesa/drivers/common/driverfuncs.c
+++ b/mesalib/src/mesa/drivers/common/driverfuncs.c
@@ -1,329 +1,329 @@
-/*

- * Mesa 3-D graphics library

- * Version:  7.1

- *

- * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sublicense,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- */

-

-

-#include "main/glheader.h"

-#include "main/imports.h"

-#include "main/arrayobj.h"

-#include "main/context.h"

-#include "main/framebuffer.h"

-#include "main/mipmap.h"

-#include "main/queryobj.h"

-#include "main/renderbuffer.h"

-#include "main/shaderobj.h"

-#include "main/texcompress.h"

-#include "main/texformat.h"

-#include "main/texgetimage.h"

-#include "main/teximage.h"

-#include "main/texobj.h"

-#include "main/texstore.h"

-#include "main/bufferobj.h"

-#include "main/fbobject.h"

-#include "main/samplerobj.h"

-#include "main/syncobj.h"

-#include "main/texturebarrier.h"

-#include "main/transformfeedback.h"

-

-#include "program/program.h"

-#include "tnl/tnl.h"

-#include "swrast/swrast.h"

-

-#include "driverfuncs.h"

-#include "meta.h"

-

-

-

-/**

- * Plug in default functions for all pointers in the dd_function_table

- * structure.

- * Device drivers should call this function and then plug in any

- * functions which it wants to override.

- * Some functions (pointers) MUST be implemented by all drivers (REQUIRED).

- *

- * \param table the dd_function_table to initialize

- */

-void

-_mesa_init_driver_functions(struct dd_function_table *driver)

-{

-   memset(driver, 0, sizeof(*driver));

-

-   driver->GetString = NULL;  /* REQUIRED! */

-   driver->UpdateState = NULL;  /* REQUIRED! */

-   driver->GetBufferSize = NULL;  /* REQUIRED! */

-   driver->ResizeBuffers = _mesa_resize_framebuffer;

-   driver->Error = NULL;

-

-   driver->Finish = NULL;

-   driver->Flush = NULL;

-

-   /* framebuffer/image functions */

-   driver->Clear = _swrast_Clear;

-   driver->Accum = _swrast_Accum;

-   driver->RasterPos = _tnl_RasterPos;

-   driver->DrawPixels = _swrast_DrawPixels;

-   driver->ReadPixels = _swrast_ReadPixels;

-   driver->CopyPixels = _swrast_CopyPixels;

-   driver->Bitmap = _swrast_Bitmap;

-

-   /* Texture functions */

-   driver->ChooseTextureFormat = _mesa_choose_tex_format;

-   driver->TexImage1D = _mesa_store_teximage1d;

-   driver->TexImage2D = _mesa_store_teximage2d;

-   driver->TexImage3D = _mesa_store_teximage3d;

-   driver->TexSubImage1D = _mesa_store_texsubimage1d;

-   driver->TexSubImage2D = _mesa_store_texsubimage2d;

-   driver->TexSubImage3D = _mesa_store_texsubimage3d;

-   driver->GetTexImage = _mesa_meta_GetTexImage;

-   driver->CopyTexSubImage1D = _mesa_meta_CopyTexSubImage1D;

-   driver->CopyTexSubImage2D = _mesa_meta_CopyTexSubImage2D;

-   driver->CopyTexSubImage3D = _mesa_meta_CopyTexSubImage3D;

-   driver->GenerateMipmap = _mesa_meta_GenerateMipmap;

-   driver->TestProxyTexImage = _mesa_test_proxy_teximage;

-   driver->CompressedTexImage1D = _mesa_store_compressed_teximage1d;

-   driver->CompressedTexImage2D = _mesa_store_compressed_teximage2d;

-   driver->CompressedTexImage3D = _mesa_store_compressed_teximage3d;

-   driver->CompressedTexSubImage1D = _mesa_store_compressed_texsubimage1d;

-   driver->CompressedTexSubImage2D = _mesa_store_compressed_texsubimage2d;

-   driver->CompressedTexSubImage3D = _mesa_store_compressed_texsubimage3d;

-   driver->GetCompressedTexImage = _mesa_get_compressed_teximage;

-   driver->BindTexture = NULL;

-   driver->NewTextureObject = _mesa_new_texture_object;

-   driver->DeleteTexture = _mesa_delete_texture_object;

-   driver->NewTextureImage = _mesa_new_texture_image;

-   driver->FreeTextureImageBuffer = _mesa_free_texture_image_data;

-   driver->MapTextureImage = _swrast_map_teximage;

-   driver->UnmapTextureImage = _swrast_unmap_teximage;

-   driver->MapTexture = NULL;

-   driver->UnmapTexture = NULL;

-   driver->TextureMemCpy = memcpy;

-   driver->IsTextureResident = NULL;

-

-   /* Vertex/fragment programs */

-   driver->BindProgram = NULL;

-   driver->NewProgram = _mesa_new_program;

-   driver->DeleteProgram = _mesa_delete_program;

-

-   /* simple state commands */

-   driver->AlphaFunc = NULL;

-   driver->BlendColor = NULL;

-   driver->BlendEquationSeparate = NULL;

-   driver->BlendFuncSeparate = NULL;

-   driver->ClearColor = NULL;

-   driver->ClearDepth = NULL;

-   driver->ClearStencil = NULL;

-   driver->ClipPlane = NULL;

-   driver->ColorMask = NULL;

-   driver->ColorMaterial = NULL;

-   driver->CullFace = NULL;

-   driver->DrawBuffer = NULL;

-   driver->DrawBuffers = NULL;

-   driver->FrontFace = NULL;

-   driver->DepthFunc = NULL;

-   driver->DepthMask = NULL;

-   driver->DepthRange = NULL;

-   driver->Enable = NULL;

-   driver->Fogfv = NULL;

-   driver->Hint = NULL;

-   driver->Lightfv = NULL;

-   driver->LightModelfv = NULL;

-   driver->LineStipple = NULL;

-   driver->LineWidth = NULL;

-   driver->LogicOpcode = NULL;

-   driver->PointParameterfv = NULL;

-   driver->PointSize = NULL;

-   driver->PolygonMode = NULL;

-   driver->PolygonOffset = NULL;

-   driver->PolygonStipple = NULL;

-   driver->ReadBuffer = NULL;

-   driver->RenderMode = NULL;

-   driver->Scissor = NULL;

-   driver->ShadeModel = NULL;

-   driver->StencilFuncSeparate = NULL;

-   driver->StencilOpSeparate = NULL;

-   driver->StencilMaskSeparate = NULL;

-   driver->TexGen = NULL;

-   driver->TexEnv = NULL;

-   driver->TexParameter = NULL;

-   driver->Viewport = NULL;

-

-   /* buffer objects */

-   _mesa_init_buffer_object_functions(driver);

-

-   /* query objects */

-   _mesa_init_query_object_functions(driver);

-

-   _mesa_init_sync_object_functions(driver);

-

-   driver->NewFramebuffer = _mesa_new_framebuffer;

-   driver->NewRenderbuffer = _mesa_new_soft_renderbuffer;

-   driver->RenderTexture = _swrast_render_texture;

-   driver->FinishRenderTexture = _swrast_finish_render_texture;

-   driver->FramebufferRenderbuffer = _mesa_framebuffer_renderbuffer;

-   driver->ValidateFramebuffer = _mesa_validate_framebuffer;

-

-   driver->BlitFramebuffer = _swrast_BlitFramebuffer;

-

-   _mesa_init_texture_barrier_functions(driver);

-

-   /* APPLE_vertex_array_object */

-   driver->NewArrayObject = _mesa_new_array_object;

-   driver->DeleteArrayObject = _mesa_delete_array_object;

-   driver->BindArrayObject = NULL;

-

-   _mesa_init_shader_object_functions(driver);

-

-   _mesa_init_transform_feedback_functions(driver);

-

-   _mesa_init_sampler_object_functions(driver);

-

-   /* T&L stuff */

-   driver->NeedValidate = GL_FALSE;

-   driver->ValidateTnlModule = NULL;

-   driver->CurrentExecPrimitive = 0;

-   driver->CurrentSavePrimitive = 0;

-   driver->NeedFlush = 0;

-   driver->SaveNeedFlush = 0;

-

-   driver->ProgramStringNotify = _tnl_program_string;

-   driver->FlushVertices = NULL;

-   driver->SaveFlushVertices = NULL;

-   driver->NotifySaveBegin = NULL;

-   driver->LightingSpaceChange = NULL;

-

-   /* display list */

-   driver->NewList = NULL;

-   driver->EndList = NULL;

-   driver->BeginCallList = NULL;

-   driver->EndCallList = NULL;

-}

-

-

-/**

- * Call the ctx->Driver.* state functions with current values to initialize

- * driver state.

- * Only the Intel drivers use this so far.

- */

-void

-_mesa_init_driver_state(struct gl_context *ctx)

-{

-   ctx->Driver.AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);

-

-   ctx->Driver.BlendColor(ctx, ctx->Color.BlendColor);

-

-   ctx->Driver.BlendEquationSeparate(ctx,

-                                     ctx->Color.Blend[0].EquationRGB,

-                                     ctx->Color.Blend[0].EquationA);

-

-   ctx->Driver.BlendFuncSeparate(ctx,

-                                 ctx->Color.Blend[0].SrcRGB,

-                                 ctx->Color.Blend[0].DstRGB,

-                                 ctx->Color.Blend[0].SrcA,

-                                 ctx->Color.Blend[0].DstA);

-

-   if (ctx->Driver.ColorMaskIndexed) {

-      GLuint i;

-      for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {

-         ctx->Driver.ColorMaskIndexed(ctx, i,

-                                      ctx->Color.ColorMask[i][RCOMP],

-                                      ctx->Color.ColorMask[i][GCOMP],

-                                      ctx->Color.ColorMask[i][BCOMP],

-                                      ctx->Color.ColorMask[i][ACOMP]);

-      }

-   }

-   else {

-      ctx->Driver.ColorMask(ctx,

-                            ctx->Color.ColorMask[0][RCOMP],

-                            ctx->Color.ColorMask[0][GCOMP],

-                            ctx->Color.ColorMask[0][BCOMP],

-                            ctx->Color.ColorMask[0][ACOMP]);

-   }

-

-   ctx->Driver.CullFace(ctx, ctx->Polygon.CullFaceMode);

-   ctx->Driver.DepthFunc(ctx, ctx->Depth.Func);

-   ctx->Driver.DepthMask(ctx, ctx->Depth.Mask);

-

-   ctx->Driver.Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);

-   ctx->Driver.Enable(ctx, GL_BLEND, ctx->Color.BlendEnabled);

-   ctx->Driver.Enable(ctx, GL_COLOR_LOGIC_OP, ctx->Color.ColorLogicOpEnabled);

-   ctx->Driver.Enable(ctx, GL_COLOR_SUM, ctx->Fog.ColorSumEnabled);

-   ctx->Driver.Enable(ctx, GL_CULL_FACE, ctx->Polygon.CullFlag);

-   ctx->Driver.Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);

-   ctx->Driver.Enable(ctx, GL_DITHER, ctx->Color.DitherFlag);

-   ctx->Driver.Enable(ctx, GL_FOG, ctx->Fog.Enabled);

-   ctx->Driver.Enable(ctx, GL_LIGHTING, ctx->Light.Enabled);

-   ctx->Driver.Enable(ctx, GL_LINE_SMOOTH, ctx->Line.SmoothFlag);

-   ctx->Driver.Enable(ctx, GL_POLYGON_STIPPLE, ctx->Polygon.StippleFlag);

-   ctx->Driver.Enable(ctx, GL_SCISSOR_TEST, ctx->Scissor.Enabled);

-   ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil._Enabled);

-   ctx->Driver.Enable(ctx, GL_TEXTURE_1D, GL_FALSE);

-   ctx->Driver.Enable(ctx, GL_TEXTURE_2D, GL_FALSE);

-   ctx->Driver.Enable(ctx, GL_TEXTURE_RECTANGLE_NV, GL_FALSE);

-   ctx->Driver.Enable(ctx, GL_TEXTURE_3D, GL_FALSE);

-   ctx->Driver.Enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);

-

-   ctx->Driver.Fogfv(ctx, GL_FOG_COLOR, ctx->Fog.Color);

-   {

-      GLfloat mode = (GLfloat) ctx->Fog.Mode;

-      ctx->Driver.Fogfv(ctx, GL_FOG_MODE, &mode);

-   }

-   ctx->Driver.Fogfv(ctx, GL_FOG_DENSITY, &ctx->Fog.Density);

-   ctx->Driver.Fogfv(ctx, GL_FOG_START, &ctx->Fog.Start);

-   ctx->Driver.Fogfv(ctx, GL_FOG_END, &ctx->Fog.End);

-

-   ctx->Driver.FrontFace(ctx, ctx->Polygon.FrontFace);

-

-   {

-      GLfloat f = (GLfloat) ctx->Light.Model.ColorControl;

-      ctx->Driver.LightModelfv(ctx, GL_LIGHT_MODEL_COLOR_CONTROL, &f);

-   }

-

-   ctx->Driver.LineWidth(ctx, ctx->Line.Width);

-   ctx->Driver.LogicOpcode(ctx, ctx->Color.LogicOp);

-   ctx->Driver.PointSize(ctx, ctx->Point.Size);

-   ctx->Driver.PolygonStipple(ctx, (const GLubyte *) ctx->PolygonStipple);

-   ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,

-                       ctx->Scissor.Width, ctx->Scissor.Height);

-   ctx->Driver.ShadeModel(ctx, ctx->Light.ShadeModel);

-   ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT,

-                                   ctx->Stencil.Function[0],

-                                   ctx->Stencil.Ref[0],

-                                   ctx->Stencil.ValueMask[0]);

-   ctx->Driver.StencilFuncSeparate(ctx, GL_BACK,

-                                   ctx->Stencil.Function[1],

-                                   ctx->Stencil.Ref[1],

-                                   ctx->Stencil.ValueMask[1]);

-   ctx->Driver.StencilMaskSeparate(ctx, GL_FRONT, ctx->Stencil.WriteMask[0]);

-   ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, ctx->Stencil.WriteMask[1]);

-   ctx->Driver.StencilOpSeparate(ctx, GL_FRONT,

-                                 ctx->Stencil.FailFunc[0],

-                                 ctx->Stencil.ZFailFunc[0],

-                                 ctx->Stencil.ZPassFunc[0]);

-   ctx->Driver.StencilOpSeparate(ctx, GL_BACK,

-                                 ctx->Stencil.FailFunc[1],

-                                 ctx->Stencil.ZFailFunc[1],

-                                 ctx->Stencil.ZPassFunc[1]);

-

-

-   ctx->Driver.DrawBuffer(ctx, ctx->Color.DrawBuffer[0]);

-}

+/*
+ * Mesa 3-D graphics library
+ * Version:  7.1
+ *
+ * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+#include "main/glheader.h"
+#include "main/imports.h"
+#include "main/arrayobj.h"
+#include "main/context.h"
+#include "main/framebuffer.h"
+#include "main/mipmap.h"
+#include "main/queryobj.h"
+#include "main/renderbuffer.h"
+#include "main/shaderobj.h"
+#include "main/texcompress.h"
+#include "main/texformat.h"
+#include "main/texgetimage.h"
+#include "main/teximage.h"
+#include "main/texobj.h"
+#include "main/texstore.h"
+#include "main/bufferobj.h"
+#include "main/fbobject.h"
+#include "main/samplerobj.h"
+#include "main/syncobj.h"
+#include "main/texturebarrier.h"
+#include "main/transformfeedback.h"
+
+#include "program/program.h"
+#include "tnl/tnl.h"
+#include "swrast/swrast.h"
+
+#include "driverfuncs.h"
+#include "meta.h"
+
+
+
+/**
+ * Plug in default functions for all pointers in the dd_function_table
+ * structure.
+ * Device drivers should call this function and then plug in any
+ * functions which it wants to override.
+ * Some functions (pointers) MUST be implemented by all drivers (REQUIRED).
+ *
+ * \param table the dd_function_table to initialize
+ */
+void
+_mesa_init_driver_functions(struct dd_function_table *driver)
+{
+   memset(driver, 0, sizeof(*driver));
+
+   driver->GetString = NULL;  /* REQUIRED! */
+   driver->UpdateState = NULL;  /* REQUIRED! */
+   driver->GetBufferSize = NULL;  /* REQUIRED! */
+   driver->ResizeBuffers = _mesa_resize_framebuffer;
+   driver->Error = NULL;
+
+   driver->Finish = NULL;
+   driver->Flush = NULL;
+
+   /* framebuffer/image functions */
+   driver->Clear = _swrast_Clear;
+   driver->Accum = _swrast_Accum;
+   driver->RasterPos = _tnl_RasterPos;
+   driver->DrawPixels = _swrast_DrawPixels;
+   driver->ReadPixels = _swrast_ReadPixels;
+   driver->CopyPixels = _swrast_CopyPixels;
+   driver->Bitmap = _swrast_Bitmap;
+
+   /* Texture functions */
+   driver->ChooseTextureFormat = _mesa_choose_tex_format;
+   driver->TexImage1D = _mesa_store_teximage1d;
+   driver->TexImage2D = _mesa_store_teximage2d;
+   driver->TexImage3D = _mesa_store_teximage3d;
+   driver->TexSubImage1D = _mesa_store_texsubimage1d;
+   driver->TexSubImage2D = _mesa_store_texsubimage2d;
+   driver->TexSubImage3D = _mesa_store_texsubimage3d;
+   driver->GetTexImage = _mesa_meta_GetTexImage;
+   driver->CopyTexSubImage1D = _mesa_meta_CopyTexSubImage1D;
+   driver->CopyTexSubImage2D = _mesa_meta_CopyTexSubImage2D;
+   driver->CopyTexSubImage3D = _mesa_meta_CopyTexSubImage3D;
+   driver->GenerateMipmap = _mesa_meta_GenerateMipmap;
+   driver->TestProxyTexImage = _mesa_test_proxy_teximage;
+   driver->CompressedTexImage1D = _mesa_store_compressed_teximage1d;
+   driver->CompressedTexImage2D = _mesa_store_compressed_teximage2d;
+   driver->CompressedTexImage3D = _mesa_store_compressed_teximage3d;
+   driver->CompressedTexSubImage1D = _mesa_store_compressed_texsubimage1d;
+   driver->CompressedTexSubImage2D = _mesa_store_compressed_texsubimage2d;
+   driver->CompressedTexSubImage3D = _mesa_store_compressed_texsubimage3d;
+   driver->GetCompressedTexImage = _mesa_get_compressed_teximage;
+   driver->BindTexture = NULL;
+   driver->NewTextureObject = _mesa_new_texture_object;
+   driver->DeleteTexture = _mesa_delete_texture_object;
+   driver->NewTextureImage = _mesa_new_texture_image;
+   driver->FreeTextureImageBuffer = _mesa_free_texture_image_data;
+   driver->MapTextureImage = _swrast_map_teximage;
+   driver->UnmapTextureImage = _swrast_unmap_teximage;
+   driver->MapTexture = NULL;
+   driver->UnmapTexture = NULL;
+   driver->TextureMemCpy = memcpy;
+   driver->IsTextureResident = NULL;
+
+   /* Vertex/fragment programs */
+   driver->BindProgram = NULL;
+   driver->NewProgram = _mesa_new_program;
+   driver->DeleteProgram = _mesa_delete_program;
+
+   /* simple state commands */
+   driver->AlphaFunc = NULL;
+   driver->BlendColor = NULL;
+   driver->BlendEquationSeparate = NULL;
+   driver->BlendFuncSeparate = NULL;
+   driver->ClearColor = NULL;
+   driver->ClearDepth = NULL;
+   driver->ClearStencil = NULL;
+   driver->ClipPlane = NULL;
+   driver->ColorMask = NULL;
+   driver->ColorMaterial = NULL;
+   driver->CullFace = NULL;
+   driver->DrawBuffer = NULL;
+   driver->DrawBuffers = NULL;
+   driver->FrontFace = NULL;
+   driver->DepthFunc = NULL;
+   driver->DepthMask = NULL;
+   driver->DepthRange = NULL;
+   driver->Enable = NULL;
+   driver->Fogfv = NULL;
+   driver->Hint = NULL;
+   driver->Lightfv = NULL;
+   driver->LightModelfv = NULL;
+   driver->LineStipple = NULL;
+   driver->LineWidth = NULL;
+   driver->LogicOpcode = NULL;
+   driver->PointParameterfv = NULL;
+   driver->PointSize = NULL;
+   driver->PolygonMode = NULL;
+   driver->PolygonOffset = NULL;
+   driver->PolygonStipple = NULL;
+   driver->ReadBuffer = NULL;
+   driver->RenderMode = NULL;
+   driver->Scissor = NULL;
+   driver->ShadeModel = NULL;
+   driver->StencilFuncSeparate = NULL;
+   driver->StencilOpSeparate = NULL;
+   driver->StencilMaskSeparate = NULL;
+   driver->TexGen = NULL;
+   driver->TexEnv = NULL;
+   driver->TexParameter = NULL;
+   driver->Viewport = NULL;
+
+   /* buffer objects */
+   _mesa_init_buffer_object_functions(driver);
+
+   /* query objects */
+   _mesa_init_query_object_functions(driver);
+
+   _mesa_init_sync_object_functions(driver);
+
+   driver->NewFramebuffer = _mesa_new_framebuffer;
+   driver->NewRenderbuffer = _mesa_new_soft_renderbuffer;
+   driver->RenderTexture = _swrast_render_texture;
+   driver->FinishRenderTexture = _swrast_finish_render_texture;
+   driver->FramebufferRenderbuffer = _mesa_framebuffer_renderbuffer;
+   driver->ValidateFramebuffer = _mesa_validate_framebuffer;
+
+   driver->BlitFramebuffer = _swrast_BlitFramebuffer;
+
+   _mesa_init_texture_barrier_functions(driver);
+
+   /* APPLE_vertex_array_object */
+   driver->NewArrayObject = _mesa_new_array_object;
+   driver->DeleteArrayObject = _mesa_delete_array_object;
+   driver->BindArrayObject = NULL;
+
+   _mesa_init_shader_object_functions(driver);
+
+   _mesa_init_transform_feedback_functions(driver);
+
+   _mesa_init_sampler_object_functions(driver);
+
+   /* T&L stuff */
+   driver->NeedValidate = GL_FALSE;
+   driver->ValidateTnlModule = NULL;
+   driver->CurrentExecPrimitive = 0;
+   driver->CurrentSavePrimitive = 0;
+   driver->NeedFlush = 0;
+   driver->SaveNeedFlush = 0;
+
+   driver->ProgramStringNotify = _tnl_program_string;
+   driver->FlushVertices = NULL;
+   driver->SaveFlushVertices = NULL;
+   driver->NotifySaveBegin = NULL;
+   driver->LightingSpaceChange = NULL;
+
+   /* display list */
+   driver->NewList = NULL;
+   driver->EndList = NULL;
+   driver->BeginCallList = NULL;
+   driver->EndCallList = NULL;
+}
+
+
+/**
+ * Call the ctx->Driver.* state functions with current values to initialize
+ * driver state.
+ * Only the Intel drivers use this so far.
+ */
+void
+_mesa_init_driver_state(struct gl_context *ctx)
+{
+   ctx->Driver.AlphaFunc(ctx, ctx->Color.AlphaFunc, ctx->Color.AlphaRef);
+
+   ctx->Driver.BlendColor(ctx, ctx->Color.BlendColor);
+
+   ctx->Driver.BlendEquationSeparate(ctx,
+                                     ctx->Color.Blend[0].EquationRGB,
+                                     ctx->Color.Blend[0].EquationA);
+
+   ctx->Driver.BlendFuncSeparate(ctx,
+                                 ctx->Color.Blend[0].SrcRGB,
+                                 ctx->Color.Blend[0].DstRGB,
+                                 ctx->Color.Blend[0].SrcA,
+                                 ctx->Color.Blend[0].DstA);
+
+   if (ctx->Driver.ColorMaskIndexed) {
+      GLuint i;
+      for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
+         ctx->Driver.ColorMaskIndexed(ctx, i,
+                                      ctx->Color.ColorMask[i][RCOMP],
+                                      ctx->Color.ColorMask[i][GCOMP],
+                                      ctx->Color.ColorMask[i][BCOMP],
+                                      ctx->Color.ColorMask[i][ACOMP]);
+      }
+   }
+   else {
+      ctx->Driver.ColorMask(ctx,
+                            ctx->Color.ColorMask[0][RCOMP],
+                            ctx->Color.ColorMask[0][GCOMP],
+                            ctx->Color.ColorMask[0][BCOMP],
+                            ctx->Color.ColorMask[0][ACOMP]);
+   }
+
+   ctx->Driver.CullFace(ctx, ctx->Polygon.CullFaceMode);
+   ctx->Driver.DepthFunc(ctx, ctx->Depth.Func);
+   ctx->Driver.DepthMask(ctx, ctx->Depth.Mask);
+
+   ctx->Driver.Enable(ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled);
+   ctx->Driver.Enable(ctx, GL_BLEND, ctx->Color.BlendEnabled);
+   ctx->Driver.Enable(ctx, GL_COLOR_LOGIC_OP, ctx->Color.ColorLogicOpEnabled);
+   ctx->Driver.Enable(ctx, GL_COLOR_SUM, ctx->Fog.ColorSumEnabled);
+   ctx->Driver.Enable(ctx, GL_CULL_FACE, ctx->Polygon.CullFlag);
+   ctx->Driver.Enable(ctx, GL_DEPTH_TEST, ctx->Depth.Test);
+   ctx->Driver.Enable(ctx, GL_DITHER, ctx->Color.DitherFlag);
+   ctx->Driver.Enable(ctx, GL_FOG, ctx->Fog.Enabled);
+   ctx->Driver.Enable(ctx, GL_LIGHTING, ctx->Light.Enabled);
+   ctx->Driver.Enable(ctx, GL_LINE_SMOOTH, ctx->Line.SmoothFlag);
+   ctx->Driver.Enable(ctx, GL_POLYGON_STIPPLE, ctx->Polygon.StippleFlag);
+   ctx->Driver.Enable(ctx, GL_SCISSOR_TEST, ctx->Scissor.Enabled);
+   ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil._Enabled);
+   ctx->Driver.Enable(ctx, GL_TEXTURE_1D, GL_FALSE);
+   ctx->Driver.Enable(ctx, GL_TEXTURE_2D, GL_FALSE);
+   ctx->Driver.Enable(ctx, GL_TEXTURE_RECTANGLE_NV, GL_FALSE);
+   ctx->Driver.Enable(ctx, GL_TEXTURE_3D, GL_FALSE);
+   ctx->Driver.Enable(ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE);
+
+   ctx->Driver.Fogfv(ctx, GL_FOG_COLOR, ctx->Fog.Color);
+   {
+      GLfloat mode = (GLfloat) ctx->Fog.Mode;
+      ctx->Driver.Fogfv(ctx, GL_FOG_MODE, &mode);
+   }
+   ctx->Driver.Fogfv(ctx, GL_FOG_DENSITY, &ctx->Fog.Density);
+   ctx->Driver.Fogfv(ctx, GL_FOG_START, &ctx->Fog.Start);
+   ctx->Driver.Fogfv(ctx, GL_FOG_END, &ctx->Fog.End);
+
+   ctx->Driver.FrontFace(ctx, ctx->Polygon.FrontFace);
+
+   {
+      GLfloat f = (GLfloat) ctx->Light.Model.ColorControl;
+      ctx->Driver.LightModelfv(ctx, GL_LIGHT_MODEL_COLOR_CONTROL, &f);
+   }
+
+   ctx->Driver.LineWidth(ctx, ctx->Line.Width);
+   ctx->Driver.LogicOpcode(ctx, ctx->Color.LogicOp);
+   ctx->Driver.PointSize(ctx, ctx->Point.Size);
+   ctx->Driver.PolygonStipple(ctx, (const GLubyte *) ctx->PolygonStipple);
+   ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
+                       ctx->Scissor.Width, ctx->Scissor.Height);
+   ctx->Driver.ShadeModel(ctx, ctx->Light.ShadeModel);
+   ctx->Driver.StencilFuncSeparate(ctx, GL_FRONT,
+                                   ctx->Stencil.Function[0],
+                                   ctx->Stencil.Ref[0],
+                                   ctx->Stencil.ValueMask[0]);
+   ctx->Driver.StencilFuncSeparate(ctx, GL_BACK,
+                                   ctx->Stencil.Function[1],
+                                   ctx->Stencil.Ref[1],
+                                   ctx->Stencil.ValueMask[1]);
+   ctx->Driver.StencilMaskSeparate(ctx, GL_FRONT, ctx->Stencil.WriteMask[0]);
+   ctx->Driver.StencilMaskSeparate(ctx, GL_BACK, ctx->Stencil.WriteMask[1]);
+   ctx->Driver.StencilOpSeparate(ctx, GL_FRONT,
+                                 ctx->Stencil.FailFunc[0],
+                                 ctx->Stencil.ZFailFunc[0],
+                                 ctx->Stencil.ZPassFunc[0]);
+   ctx->Driver.StencilOpSeparate(ctx, GL_BACK,
+                                 ctx->Stencil.FailFunc[1],
+                                 ctx->Stencil.ZFailFunc[1],
+                                 ctx->Stencil.ZPassFunc[1]);
+
+
+   ctx->Driver.DrawBuffer(ctx, ctx->Color.DrawBuffer[0]);
+}
diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.c b/mesalib/src/mesa/drivers/dri/common/dri_util.c
index adc6716c6..6d6401934 100644
--- a/mesalib/src/mesa/drivers/dri/common/dri_util.c
+++ b/mesalib/src/mesa/drivers/dri/common/dri_util.c
@@ -1,1040 +1,1040 @@
-/**

- * \file dri_util.c

- * DRI utility functions.

- *

- * This module acts as glue between GLX and the actual hardware driver.  A DRI

- * driver doesn't really \e have to use any of this - it's optional.  But, some

- * useful stuff is done here that otherwise would have to be duplicated in most

- * drivers.

- * 

- * Basically, these utility functions take care of some of the dirty details of

- * screen initialization, context creation, context binding, DRM setup, etc.

- *

- * These functions are compiled into each DRI driver so libGL.so knows nothing

- * about them.

- */

-

-

-#include <assert.h>

-#include <stdarg.h>

-#include <unistd.h>

-#include <sys/mman.h>

-#include <stdio.h>

-

-#ifndef MAP_FAILED

-#define MAP_FAILED ((void *)-1)

-#endif

-

-#include "main/imports.h"

-#define None 0

-

-#include "dri_util.h"

-#include "drm_sarea.h"

-#include "utils.h"

-#include "xmlpool.h"

-#include "../glsl/glsl_parser_extras.h"

-

-PUBLIC const char __dri2ConfigOptions[] =

-   DRI_CONF_BEGIN

-      DRI_CONF_SECTION_PERFORMANCE

-         DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1)

-      DRI_CONF_SECTION_END

-   DRI_CONF_END;

-

-static const uint __dri2NConfigOptions = 1;

-

-#ifndef GLX_OML_sync_control

-typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);

-#endif

-

-static void dri_get_drawable(__DRIdrawable *pdp);

-static void dri_put_drawable(__DRIdrawable *pdp);

-

-/**

- * This is just a token extension used to signal that the driver

- * supports setting a read drawable.

- */

-const __DRIextension driReadDrawableExtension = {

-    __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION

-};

-

-GLint

-driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )

-{

-   if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;

-   if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;

-   if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;

-   if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;

-

-   if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;

-

-   return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);

-}

-

-/*****************************************************************/

-/** \name Context (un)binding functions                          */

-/*****************************************************************/

-/*@{*/

-

-/**

- * Unbind context.

- * 

- * \param scrn the screen.

- * \param gc context.

- *

- * \return \c GL_TRUE on success, or \c GL_FALSE on failure.

- * 

- * \internal

- * This function calls __DriverAPIRec::UnbindContext, and then decrements

- * __DRIdrawableRec::refcount which must be non-zero for a successful

- * return.

- * 

- * While casting the opaque private pointers associated with the parameters

- * into their respective real types it also assures they are not \c NULL. 

- */

-static int driUnbindContext(__DRIcontext *pcp)

-{

-    __DRIscreen *psp;

-    __DRIdrawable *pdp;

-    __DRIdrawable *prp;

-

-    /*

-    ** Assume error checking is done properly in glXMakeCurrent before

-    ** calling driUnbindContext.

-    */

-

-    if (pcp == NULL)

-        return GL_FALSE;

-

-    psp = pcp->driScreenPriv;

-    pdp = pcp->driDrawablePriv;

-    prp = pcp->driReadablePriv;

-

-    /* already unbound */

-    if (!pdp && !prp)

-      return GL_TRUE;

-    /* Let driver unbind drawable from context */

-    (*psp->DriverAPI.UnbindContext)(pcp);

-

-    assert(pdp);

-    if (pdp->refcount == 0) {

-	/* ERROR!!! */

-	return GL_FALSE;

-    }

-

-    dri_put_drawable(pdp);

-

-    if (prp != pdp) {

-        if (prp->refcount == 0) {

-	    /* ERROR!!! */

-	    return GL_FALSE;

-	}

-

-    	dri_put_drawable(prp);

-    }

-

-

-    /* XXX this is disabled so that if we call SwapBuffers on an unbound

-     * window we can determine the last context bound to the window and

-     * use that context's lock. (BrianP, 2-Dec-2000)

-     */

-    pcp->driDrawablePriv = pcp->driReadablePriv = NULL;

-

-    return GL_TRUE;

-}

-

-/**

- * This function takes both a read buffer and a draw buffer.  This is needed

- * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent

- * function.

- */

-static int driBindContext(__DRIcontext *pcp,

-			  __DRIdrawable *pdp,

-			  __DRIdrawable *prp)

-{

-    __DRIscreen *psp = NULL;

-

-    /*

-    ** Assume error checking is done properly in glXMakeCurrent before

-    ** calling driUnbindContext.

-    */

-

-    if (!pcp)

-	return GL_FALSE;

-

-    /* Bind the drawable to the context */

-    psp = pcp->driScreenPriv;

-    pcp->driDrawablePriv = pdp;

-    pcp->driReadablePriv = prp;

-    if (pdp) {

-	pdp->driContextPriv = pcp;

-	dri_get_drawable(pdp);

-    }

-    if (prp && pdp != prp) {

-	dri_get_drawable(prp);

-    }

-

-    /*

-    ** Now that we have a context associated with this drawable, we can

-    ** initialize the drawable information if has not been done before.

-    */

-

-    if (!psp->dri2.enabled) {

-	if (pdp && !pdp->pStamp) {

-	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-	    __driUtilUpdateDrawableInfo(pdp);

-	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-	}

-	if (prp && pdp != prp && !prp->pStamp) {

-	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-	    __driUtilUpdateDrawableInfo(prp);

-	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-        }

-    }

-

-    /* Call device-specific MakeCurrent */

-    return (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);

-}

-

-/*@}*/

-

-

-/*****************************************************************/

-/** \name Drawable handling functions                            */

-/*****************************************************************/

-/*@{*/

-

-/**

- * Update private drawable information.

- *

- * \param pdp pointer to the private drawable information to update.

- * 

- * This function basically updates the __DRIdrawable struct's

- * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.

- * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which

- * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If

- * the values are different that means we have to update the clipping

- * info.

- */

-void

-__driUtilUpdateDrawableInfo(__DRIdrawable *pdp)

-{

-    __DRIscreen *psp = pdp->driScreenPriv;

-    __DRIcontext *pcp = pdp->driContextPriv;

-    

-    if (!pcp 

-	|| ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {

-	/* ERROR!!! 

-	 * ...but we must ignore it. There can be many contexts bound to a

-	 * drawable.

-	 */

-    }

-

-    if (pdp->pClipRects) {

-	free(pdp->pClipRects); 

-	pdp->pClipRects = NULL;

-    }

-

-    if (pdp->pBackClipRects) {

-	free(pdp->pBackClipRects); 

-	pdp->pBackClipRects = NULL;

-    }

-

-    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-

-    if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,

-			  &pdp->index, &pdp->lastStamp,

-			  &pdp->x, &pdp->y, &pdp->w, &pdp->h,

-			  &pdp->numClipRects, &pdp->pClipRects,

-			  &pdp->backX,

-			  &pdp->backY,

-			  &pdp->numBackClipRects,

-			  &pdp->pBackClipRects,

-			  pdp->loaderPrivate)) {

-	/* Error -- eg the window may have been destroyed.  Keep going

-	 * with no cliprects.

-	 */

-        pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */

-	pdp->numClipRects = 0;

-	pdp->pClipRects = NULL;

-	pdp->numBackClipRects = 0;

-	pdp->pBackClipRects = NULL;

-    }

-    else

-       pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);

-

-    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);

-}

-

-/*@}*/

-

-/*****************************************************************/

-/** \name GLX callbacks                                          */

-/*****************************************************************/

-/*@{*/

-

-static void driReportDamage(__DRIdrawable *pdp,

-			    struct drm_clip_rect *pClipRects, int numClipRects)

-{

-    __DRIscreen *psp = pdp->driScreenPriv;

-

-    /* Check that we actually have the new damage report method */

-    if (psp->damage) {

-	/* Report the damage.  Currently, all our drivers draw

-	 * directly to the front buffer, so we report the damage there

-	 * rather than to the backing storein (if any).

-	 */

-	(*psp->damage->reportDamage)(pdp,

-				     pdp->x, pdp->y,

-				     pClipRects, numClipRects,

-				     GL_TRUE, pdp->loaderPrivate);

-    }

-}

-

-

-/**

- * Swap buffers.

- *

- * \param drawablePrivate opaque pointer to the per-drawable private info.

- * 

- * \internal

- * This function calls __DRIdrawable::swapBuffers.

- * 

- * Is called directly from glXSwapBuffers().

- */

-static void driSwapBuffers(__DRIdrawable *dPriv)

-{

-    __DRIscreen *psp = dPriv->driScreenPriv;

-    drm_clip_rect_t *rects;

-    int i;

-

-    psp->DriverAPI.SwapBuffers(dPriv);

-

-    if (!dPriv->numClipRects)

-        return;

-

-    rects = malloc(sizeof(*rects) * dPriv->numClipRects);

-

-    if (!rects)

-        return;

-

-    for (i = 0; i < dPriv->numClipRects; i++) {

-        rects[i].x1 = dPriv->pClipRects[i].x1 - dPriv->x;

-        rects[i].y1 = dPriv->pClipRects[i].y1 - dPriv->y;

-        rects[i].x2 = dPriv->pClipRects[i].x2 - dPriv->x;

-        rects[i].y2 = dPriv->pClipRects[i].y2 - dPriv->y;

-    }

-

-    driReportDamage(dPriv, rects, dPriv->numClipRects);

-    free(rects);

-}

-

-static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,

-			      int64_t *msc )

-{

-    return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);

-}

-

-

-static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,

-			 int64_t divisor, int64_t remainder,

-			 int64_t * msc, int64_t * sbc)

-{

-    __DRIswapInfo  sInfo;

-    int  status;

-

-    status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,

-                                                         divisor, remainder,

-                                                         msc );

-

-    /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync

-     * is supported but GLX_OML_sync_control is not.  Therefore, don't return

-     * an error value if GetSwapInfo() is not implemented.

-    */

-    if ( status == 0

-         && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {

-        status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );

-        *sbc = sInfo.swap_count;

-    }

-

-    return status;

-}

-

-

-const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {

-    { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },

-    driWaitForMSC,

-    driDrawableGetMSC,

-};

-

-

-static void driCopySubBuffer(__DRIdrawable *dPriv,

-			      int x, int y, int w, int h)

-{

-    drm_clip_rect_t rect;

-

-    rect.x1 = x;

-    rect.y1 = dPriv->h - y - h;

-    rect.x2 = x + w;

-    rect.y2 = rect.y1 + h;

-    driReportDamage(dPriv, &rect, 1);

-

-    dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);

-}

-

-const __DRIcopySubBufferExtension driCopySubBufferExtension = {

-    { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },

-    driCopySubBuffer

-};

-

-static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)

-{

-    dPriv->swap_interval = interval;

-}

-

-static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)

-{

-    return dPriv->swap_interval;

-}

-

-const __DRIswapControlExtension driSwapControlExtension = {

-    { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },

-    driSetSwapInterval,

-    driGetSwapInterval

-};

-

-

-/**

- * This is called via __DRIscreenRec's createNewDrawable pointer.

- */

-static __DRIdrawable *

-driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,

-		     drm_drawable_t hwDrawable, int renderType,

-		     const int *attrs, void *data)

-{

-    __DRIdrawable *pdp;

-

-    /* Since pbuffers are not yet supported, no drawable attributes are

-     * supported either.

-     */

-    (void) attrs;

-    (void) renderType;

-

-    pdp = malloc(sizeof *pdp);

-    if (!pdp) {

-	return NULL;

-    }

-

-    pdp->driContextPriv = NULL;

-    pdp->loaderPrivate = data;

-    pdp->hHWDrawable = hwDrawable;

-    pdp->refcount = 1;

-    pdp->pStamp = NULL;

-    pdp->lastStamp = 0;

-    pdp->index = 0;

-    pdp->x = 0;

-    pdp->y = 0;

-    pdp->w = 0;

-    pdp->h = 0;

-    pdp->numClipRects = 0;

-    pdp->numBackClipRects = 0;

-    pdp->pClipRects = NULL;

-    pdp->pBackClipRects = NULL;

-    pdp->vblSeq = 0;

-    pdp->vblFlags = 0;

-

-    pdp->driScreenPriv = psp;

-

-    if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes, 0)) {

-       free(pdp);

-       return NULL;

-    }

-

-    pdp->msc_base = 0;

-

-    /* This special default value is replaced with the configured

-     * default value when the drawable is first bound to a direct

-     * rendering context. 

-     */

-    pdp->swap_interval = (unsigned)-1;

-

-    return pdp;

-}

-

-

-static __DRIdrawable *

-dri2CreateNewDrawable(__DRIscreen *screen,

-		      const __DRIconfig *config,

-		      void *loaderPrivate)

-{

-    __DRIdrawable *pdraw;

-

-    pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);

-    if (!pdraw)

-    	return NULL;

-

-    pdraw->pClipRects = &pdraw->dri2.clipRect;

-    pdraw->pBackClipRects = &pdraw->dri2.clipRect;

-

-    pdraw->pStamp = &pdraw->dri2.stamp;

-    *pdraw->pStamp = pdraw->lastStamp + 1;

-

-    return pdraw;

-}

-

-static __DRIbuffer *

-dri2AllocateBuffer(__DRIscreen *screen,

-		   unsigned int attachment, unsigned int format,

-		   int width, int height)

-{

-    return (*screen->DriverAPI.AllocateBuffer)(screen, attachment, format,

-					       width, height);

-}

-

-static void

-dri2ReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)

-{

-   (*screen->DriverAPI.ReleaseBuffer)(screen, buffer);

-}

-

-

-static int

-dri2ConfigQueryb(__DRIscreen *screen, const char *var, GLboolean *val)

-{

-   if (!driCheckOption(&screen->optionCache, var, DRI_BOOL))

-      return -1;

-

-   *val = driQueryOptionb(&screen->optionCache, var);

-

-   return 0;

-}

-

-static int

-dri2ConfigQueryi(__DRIscreen *screen, const char *var, GLint *val)

-{

-   if (!driCheckOption(&screen->optionCache, var, DRI_INT) &&

-       !driCheckOption(&screen->optionCache, var, DRI_ENUM))

-      return -1;

-

-    *val = driQueryOptioni(&screen->optionCache, var);

-

-    return 0;

-}

-

-static int

-dri2ConfigQueryf(__DRIscreen *screen, const char *var, GLfloat *val)

-{

-   if (!driCheckOption(&screen->optionCache, var, DRI_FLOAT))

-      return -1;

-

-    *val = driQueryOptionf(&screen->optionCache, var);

-

-    return 0;

-}

-

-

-static void dri_get_drawable(__DRIdrawable *pdp)

-{

-    pdp->refcount++;

-}

-	

-static void dri_put_drawable(__DRIdrawable *pdp)

-{

-    __DRIscreen *psp;

-

-    if (pdp) {

-	pdp->refcount--;

-	if (pdp->refcount)

-	    return;

-

-	psp = pdp->driScreenPriv;

-        (*psp->DriverAPI.DestroyBuffer)(pdp);

-	if (pdp->pClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {

-	    free(pdp->pClipRects);

-	    pdp->pClipRects = NULL;

-	}

-	if (pdp->pBackClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {

-	    free(pdp->pBackClipRects);

-	    pdp->pBackClipRects = NULL;

-	}

-	free(pdp);

-    }

-}

-

-static void

-driDestroyDrawable(__DRIdrawable *pdp)

-{

-    dri_put_drawable(pdp);

-}

-

-/*@}*/

-

-

-/*****************************************************************/

-/** \name Context handling functions                             */

-/*****************************************************************/

-/*@{*/

-

-/**

- * Destroy the per-context private information.

- * 

- * \internal

- * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls

- * drmDestroyContext(), and finally frees \p contextPrivate.

- */

-static void

-driDestroyContext(__DRIcontext *pcp)

-{

-    if (pcp) {

-	(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);

-	free(pcp);

-    }

-}

-

-

-/**

- * Create the per-drawable private driver information.

- * 

- * \param render_type   Type of rendering target.  \c GLX_RGBA_TYPE is the only

- *                      type likely to ever be supported for direct-rendering.

- *                      However, \c GLX_RGBA_FLOAT_TYPE_ARB may eventually be

- *                      supported by some drivers.

- * \param shared        Context with which to share textures, etc. or NULL

- *

- * \returns An opaque pointer to the per-context private information on

- *          success, or \c NULL on failure.

- * 

- * \internal

- * This function allocates and fills a __DRIcontextRec structure.  It

- * performs some device independent initialization and passes all the

- * relevent information to __DriverAPIRec::CreateContext to create the

- * context.

- *

- */

-static __DRIcontext *

-driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,

-		    int render_type, __DRIcontext *shared, 

-		    drm_context_t hwContext, void *data)

-{

-    __DRIcontext *pcp;

-    void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;

-

-    (void) render_type;

-

-    pcp = malloc(sizeof *pcp);

-    if (!pcp)

-	return NULL;

-

-    pcp->driScreenPriv = psp;

-    pcp->driDrawablePriv = NULL;

-    pcp->loaderPrivate = data;

-    

-    pcp->dri2.draw_stamp = 0;

-    pcp->dri2.read_stamp = 0;

-

-    pcp->hHWContext = hwContext;

-

-    if ( !(*psp->DriverAPI.CreateContext)(API_OPENGL,

-					  &config->modes, pcp, shareCtx) ) {

-        free(pcp);

-        return NULL;

-    }

-

-    return pcp;

-}

-

-static unsigned int

-dri2GetAPIMask(__DRIscreen *screen)

-{

-    return screen->api_mask;

-}

-

-static __DRIcontext *

-dri2CreateNewContextForAPI(__DRIscreen *screen, int api,

-			   const __DRIconfig *config,

-			   __DRIcontext *shared, void *data)

-{

-    __DRIcontext *context;

-    const struct gl_config *modes = (config != NULL) ? &config->modes : NULL;

-    void *shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;

-    gl_api mesa_api;

-

-    if (!(screen->api_mask & (1 << api)))

-	return NULL;

-

-    switch (api) {

-    case __DRI_API_OPENGL:

-	    mesa_api = API_OPENGL;

-	    break;

-    case __DRI_API_GLES:

-	    mesa_api = API_OPENGLES;

-	    break;

-    case __DRI_API_GLES2:

-	    mesa_api = API_OPENGLES2;

-	    break;

-    default:

-	    return NULL;

-    }

-

-    context = malloc(sizeof *context);

-    if (!context)

-	return NULL;

-

-    context->driScreenPriv = screen;

-    context->driDrawablePriv = NULL;

-    context->loaderPrivate = data;

-    

-    if (!(*screen->DriverAPI.CreateContext)(mesa_api, modes,

-					    context, shareCtx) ) {

-        free(context);

-        return NULL;

-    }

-

-    return context;

-}

-

-

-static __DRIcontext *

-dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,

-		      __DRIcontext *shared, void *data)

-{

-   return dri2CreateNewContextForAPI(screen, __DRI_API_OPENGL,

-				     config, shared, data);

-}

-

-static int

-driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)

-{

-    (void) dest;

-    (void) src;

-    (void) mask;

-    return GL_FALSE;

-}

-

-/*@}*/

-

-

-/*****************************************************************/

-/** \name Screen handling functions                              */

-/*****************************************************************/

-/*@{*/

-

-/**

- * Destroy the per-screen private information.

- * 

- * \internal

- * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls

- * drmClose(), and finally frees \p screenPrivate.

- */

-static void driDestroyScreen(__DRIscreen *psp)

-{

-    if (psp) {

-	/* No interaction with the X-server is possible at this point.  This

-	 * routine is called after XCloseDisplay, so there is no protocol

-	 * stream open to the X-server anymore.

-	 */

-

-       _mesa_destroy_shader_compiler();

-

-	if (psp->DriverAPI.DestroyScreen)

-	    (*psp->DriverAPI.DestroyScreen)(psp);

-

-	if (!psp->dri2.enabled) {

-	   (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);

-	   (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);

-	   (void)drmCloseOnce(psp->fd);

-	} else {

-	   driDestroyOptionCache(&psp->optionCache);

-	   driDestroyOptionInfo(&psp->optionInfo);

-	}

-

-	free(psp);

-    }

-}

-

-static void

-setupLoaderExtensions(__DRIscreen *psp,

-		      const __DRIextension **extensions)

-{

-    int i;

-

-    for (i = 0; extensions[i]; i++) {

-	if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)

-	    psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];

-	if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)

-	    psp->damage = (__DRIdamageExtension *) extensions[i];

-	if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)

-	    psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];

-	if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)

-	    psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];

-	if (strcmp(extensions[i]->name, __DRI_IMAGE_LOOKUP) == 0)

-	    psp->dri2.image = (__DRIimageLookupExtension *) extensions[i];

-	if (strcmp(extensions[i]->name, __DRI_USE_INVALIDATE) == 0)

-	    psp->dri2.useInvalidate = (__DRIuseInvalidateExtension *) extensions[i];

-    }

-}

-

-/**

- * This is the bootstrap function for the driver.  libGL supplies all of the

- * requisite information about the system, and the driver initializes itself.

- * This routine also fills in the linked list pointed to by \c driver_modes

- * with the \c struct gl_config that the driver can support for windows or

- * pbuffers.

- *

- * For legacy DRI.

- * 

- * \param scrn  Index of the screen

- * \param ddx_version Version of the 2D DDX.  This may not be meaningful for

- *                    all drivers.

- * \param dri_version Version of the "server-side" DRI.

- * \param drm_version Version of the kernel DRM.

- * \param frame_buffer Data describing the location and layout of the

- *                     framebuffer.

- * \param pSAREA       Pointer to the SAREA.

- * \param fd           Device handle for the DRM.

- * \param extensions   ??

- * \param driver_modes  Returns modes suppoted by the driver

- * \param loaderPrivate  ??

- * 

- * \note There is no need to check the minimum API version in this

- * function.  Since the name of this function is versioned, it is

- * impossible for a loader that is too old to even load this driver.

- */

-static __DRIscreen *

-driCreateNewScreen(int scrn,

-		   const __DRIversion *ddx_version,

-		   const __DRIversion *dri_version,

-		   const __DRIversion *drm_version,

-		   const __DRIframebuffer *frame_buffer,

-		   drmAddress pSAREA, int fd, 

-		   const __DRIextension **extensions,

-		   const __DRIconfig ***driver_modes,

-		   void *loaderPrivate)

-{

-    static const __DRIextension *emptyExtensionList[] = { NULL };

-    __DRIscreen *psp;

-

-    (void) loaderPrivate;

-

-    if (driDriverAPI.InitScreen == NULL)

-	return NULL;

-

-    psp = calloc(1, sizeof *psp);

-    if (!psp)

-	return NULL;

-

-    setupLoaderExtensions(psp, extensions);

-

-    /*

-    ** NOT_DONE: This is used by the X server to detect when the client

-    ** has died while holding the drawable lock.  The client sets the

-    ** drawable lock to this value.

-    */

-    psp->drawLockID = 1;

-

-    psp->drm_version = *drm_version;

-    psp->ddx_version = *ddx_version;

-    psp->dri_version = *dri_version;

-

-    psp->pSAREA = pSAREA;

-    psp->lock = (drmLock *) &psp->pSAREA->lock;

-

-    psp->pFB = frame_buffer->base;

-    psp->fbSize = frame_buffer->size;

-    psp->fbStride = frame_buffer->stride;

-    psp->fbWidth = frame_buffer->width;

-    psp->fbHeight = frame_buffer->height;

-    psp->devPrivSize = frame_buffer->dev_priv_size;

-    psp->pDevPriv = frame_buffer->dev_priv;

-    psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;

-

-    psp->extensions = emptyExtensionList;

-    psp->fd = fd;

-    psp->myNum = scrn;

-    psp->dri2.enabled = GL_FALSE;

-

-    psp->DriverAPI = driDriverAPI;

-    psp->api_mask = (1 << __DRI_API_OPENGL);

-

-    *driver_modes = driDriverAPI.InitScreen(psp);

-    if (*driver_modes == NULL) {

-	free(psp);

-	return NULL;

-    }

-

-    return psp;

-}

-

-/**

- * DRI2

- */

-static __DRIscreen *

-dri2CreateNewScreen(int scrn, int fd,

-		    const __DRIextension **extensions,

-		    const __DRIconfig ***driver_configs, void *data)

-{

-    static const __DRIextension *emptyExtensionList[] = { NULL };

-    __DRIscreen *psp;

-    drmVersionPtr version;

-

-    if (driDriverAPI.InitScreen2 == NULL)

-        return NULL;

-

-    psp = calloc(1, sizeof(*psp));

-    if (!psp)

-	return NULL;

-

-    setupLoaderExtensions(psp, extensions);

-

-    version = drmGetVersion(fd);

-    if (version) {

-	psp->drm_version.major = version->version_major;

-	psp->drm_version.minor = version->version_minor;

-	psp->drm_version.patch = version->version_patchlevel;

-	drmFreeVersion(version);

-    }

-

-    psp->extensions = emptyExtensionList;

-    psp->fd = fd;

-    psp->myNum = scrn;

-    psp->dri2.enabled = GL_TRUE;

-

-    psp->DriverAPI = driDriverAPI;

-    psp->api_mask = (1 << __DRI_API_OPENGL);

-    *driver_configs = driDriverAPI.InitScreen2(psp);

-    if (*driver_configs == NULL) {

-	free(psp);

-	return NULL;

-    }

-

-    psp->DriverAPI = driDriverAPI;

-    psp->loaderPrivate = data;

-

-    driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions,

-		       __dri2NConfigOptions);

-    driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum,

-			"dri2");

-

-    return psp;

-}

-

-static const __DRIextension **driGetExtensions(__DRIscreen *psp)

-{

-    return psp->extensions;

-}

-

-/** Core interface */

-const __DRIcoreExtension driCoreExtension = {

-    { __DRI_CORE, __DRI_CORE_VERSION },

-    NULL,

-    driDestroyScreen,

-    driGetExtensions,

-    driGetConfigAttrib,

-    driIndexConfigAttrib,

-    NULL,

-    driDestroyDrawable,

-    driSwapBuffers,

-    NULL,

-    driCopyContext,

-    driDestroyContext,

-    driBindContext,

-    driUnbindContext

-};

-

-/** Legacy DRI interface */

-const __DRIlegacyExtension driLegacyExtension = {

-    { __DRI_LEGACY, __DRI_LEGACY_VERSION },

-    driCreateNewScreen,

-    driCreateNewDrawable,

-    driCreateNewContext,

-};

-

-/** DRI2 interface */

-const __DRIdri2Extension driDRI2Extension = {

-    { __DRI_DRI2, __DRI_DRI2_VERSION },

-    dri2CreateNewScreen,

-    dri2CreateNewDrawable,

-    dri2CreateNewContext,

-    dri2GetAPIMask,

-    dri2CreateNewContextForAPI,

-    dri2AllocateBuffer,

-    dri2ReleaseBuffer

-};

-

-const __DRI2configQueryExtension dri2ConfigQueryExtension = {

-   { __DRI2_CONFIG_QUERY, __DRI2_CONFIG_QUERY_VERSION },

-   dri2ConfigQueryb,

-   dri2ConfigQueryi,

-   dri2ConfigQueryf,

-};

-

-/**

- * Calculate amount of swap interval used between GLX buffer swaps.

- * 

- * The usage value, on the range [0,max], is the fraction of total swap

- * interval time used between GLX buffer swaps is calculated.

- *

- *            \f$p = t_d / (i * t_r)\f$

- * 

- * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the

- * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time

- * required for a single vertical refresh period (as returned by \c

- * glXGetMscRateOML).

- * 

- * See the documentation for the GLX_MESA_swap_frame_usage extension for more

- * details.

- *

- * \param   dPriv  Pointer to the private drawable structure.

- * \return  If less than a single swap interval time period was required

- *          between GLX buffer swaps, a number greater than 0 and less than

- *          1.0 is returned.  If exactly one swap interval time period is

- *          required, 1.0 is returned, and if more than one is required then

- *          a number greater than 1.0 will be returned.

- *

- * \sa glXSwapIntervalSGI glXGetMscRateOML

- * 

- * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it

- *       be possible to cache the sync rate?

- */

-float

-driCalculateSwapUsage( __DRIdrawable *dPriv, int64_t last_swap_ust,

-		       int64_t current_ust )

-{

-   int32_t   n;

-   int32_t   d;

-   int       interval;

-   float     usage = 1.0;

-   __DRIscreen *psp = dPriv->driScreenPriv;

-

-   if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {

-      interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;

-

-

-      /* We want to calculate

-       * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get

-       * current_UST by calling __glXGetUST.  last_swap_UST is stored in

-       * dPriv->swap_ust.  interval has already been calculated.

-       *

-       * The only tricky part is us_per_refresh.  us_per_refresh is

-       * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it

-       * around and say us_per_refresh = 1000000 * d / n.  Since this goes in

-       * the denominator of the final calculation, we calculate

-       * (interval * 1000000 * d) and move n into the numerator.

-       */

-

-      usage = (current_ust - last_swap_ust);

-      usage *= n;

-      usage /= (interval * d);

-      usage /= 1000000.0;

-   }

-   

-   return usage;

-}

-

-void

-dri2InvalidateDrawable(__DRIdrawable *drawable)

-{

-    drawable->dri2.stamp++;

-}

-

-/*@}*/

+/**
+ * \file dri_util.c
+ * DRI utility functions.
+ *
+ * This module acts as glue between GLX and the actual hardware driver.  A DRI
+ * driver doesn't really \e have to use any of this - it's optional.  But, some
+ * useful stuff is done here that otherwise would have to be duplicated in most
+ * drivers.
+ * 
+ * Basically, these utility functions take care of some of the dirty details of
+ * screen initialization, context creation, context binding, DRM setup, etc.
+ *
+ * These functions are compiled into each DRI driver so libGL.so knows nothing
+ * about them.
+ */
+
+
+#include <assert.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <stdio.h>
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void *)-1)
+#endif
+
+#include "main/imports.h"
+#define None 0
+
+#include "dri_util.h"
+#include "drm_sarea.h"
+#include "utils.h"
+#include "xmlpool.h"
+#include "../glsl/glsl_parser_extras.h"
+
+PUBLIC const char __dri2ConfigOptions[] =
+   DRI_CONF_BEGIN
+      DRI_CONF_SECTION_PERFORMANCE
+         DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_1)
+      DRI_CONF_SECTION_END
+   DRI_CONF_END;
+
+static const uint __dri2NConfigOptions = 1;
+
+#ifndef GLX_OML_sync_control
+typedef GLboolean ( * PFNGLXGETMSCRATEOMLPROC) (__DRIdrawable *drawable, int32_t *numerator, int32_t *denominator);
+#endif
+
+static void dri_get_drawable(__DRIdrawable *pdp);
+static void dri_put_drawable(__DRIdrawable *pdp);
+
+/**
+ * This is just a token extension used to signal that the driver
+ * supports setting a read drawable.
+ */
+const __DRIextension driReadDrawableExtension = {
+    __DRI_READ_DRAWABLE, __DRI_READ_DRAWABLE_VERSION
+};
+
+GLint
+driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 )
+{
+   if (rect2.x1 > rect1.x1) rect1.x1 = rect2.x1;
+   if (rect2.x2 < rect1.x2) rect1.x2 = rect2.x2;
+   if (rect2.y1 > rect1.y1) rect1.y1 = rect2.y1;
+   if (rect2.y2 < rect1.y2) rect1.y2 = rect2.y2;
+
+   if (rect1.x1 > rect1.x2 || rect1.y1 > rect1.y2) return 0;
+
+   return (rect1.x2 - rect1.x1) * (rect1.y2 - rect1.y1);
+}
+
+/*****************************************************************/
+/** \name Context (un)binding functions                          */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Unbind context.
+ * 
+ * \param scrn the screen.
+ * \param gc context.
+ *
+ * \return \c GL_TRUE on success, or \c GL_FALSE on failure.
+ * 
+ * \internal
+ * This function calls __DriverAPIRec::UnbindContext, and then decrements
+ * __DRIdrawableRec::refcount which must be non-zero for a successful
+ * return.
+ * 
+ * While casting the opaque private pointers associated with the parameters
+ * into their respective real types it also assures they are not \c NULL. 
+ */
+static int driUnbindContext(__DRIcontext *pcp)
+{
+    __DRIscreen *psp;
+    __DRIdrawable *pdp;
+    __DRIdrawable *prp;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driUnbindContext.
+    */
+
+    if (pcp == NULL)
+        return GL_FALSE;
+
+    psp = pcp->driScreenPriv;
+    pdp = pcp->driDrawablePriv;
+    prp = pcp->driReadablePriv;
+
+    /* already unbound */
+    if (!pdp && !prp)
+      return GL_TRUE;
+    /* Let driver unbind drawable from context */
+    (*psp->DriverAPI.UnbindContext)(pcp);
+
+    assert(pdp);
+    if (pdp->refcount == 0) {
+	/* ERROR!!! */
+	return GL_FALSE;
+    }
+
+    dri_put_drawable(pdp);
+
+    if (prp != pdp) {
+        if (prp->refcount == 0) {
+	    /* ERROR!!! */
+	    return GL_FALSE;
+	}
+
+    	dri_put_drawable(prp);
+    }
+
+
+    /* XXX this is disabled so that if we call SwapBuffers on an unbound
+     * window we can determine the last context bound to the window and
+     * use that context's lock. (BrianP, 2-Dec-2000)
+     */
+    pcp->driDrawablePriv = pcp->driReadablePriv = NULL;
+
+    return GL_TRUE;
+}
+
+/**
+ * This function takes both a read buffer and a draw buffer.  This is needed
+ * for \c glXMakeCurrentReadSGI or GLX 1.3's \c glXMakeContextCurrent
+ * function.
+ */
+static int driBindContext(__DRIcontext *pcp,
+			  __DRIdrawable *pdp,
+			  __DRIdrawable *prp)
+{
+    __DRIscreen *psp = NULL;
+
+    /*
+    ** Assume error checking is done properly in glXMakeCurrent before
+    ** calling driUnbindContext.
+    */
+
+    if (!pcp)
+	return GL_FALSE;
+
+    /* Bind the drawable to the context */
+    psp = pcp->driScreenPriv;
+    pcp->driDrawablePriv = pdp;
+    pcp->driReadablePriv = prp;
+    if (pdp) {
+	pdp->driContextPriv = pcp;
+	dri_get_drawable(pdp);
+    }
+    if (prp && pdp != prp) {
+	dri_get_drawable(prp);
+    }
+
+    /*
+    ** Now that we have a context associated with this drawable, we can
+    ** initialize the drawable information if has not been done before.
+    */
+
+    if (!psp->dri2.enabled) {
+	if (pdp && !pdp->pStamp) {
+	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+	    __driUtilUpdateDrawableInfo(pdp);
+	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+	}
+	if (prp && pdp != prp && !prp->pStamp) {
+	    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+	    __driUtilUpdateDrawableInfo(prp);
+	    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+        }
+    }
+
+    /* Call device-specific MakeCurrent */
+    return (*psp->DriverAPI.MakeCurrent)(pcp, pdp, prp);
+}
+
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Drawable handling functions                            */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Update private drawable information.
+ *
+ * \param pdp pointer to the private drawable information to update.
+ * 
+ * This function basically updates the __DRIdrawable struct's
+ * cliprect information by calling \c __DRIinterfaceMethods::getDrawableInfo.
+ * This is usually called by the DRI_VALIDATE_DRAWABLE_INFO macro which
+ * compares the __DRIdrwablePrivate pStamp and lastStamp values.  If
+ * the values are different that means we have to update the clipping
+ * info.
+ */
+void
+__driUtilUpdateDrawableInfo(__DRIdrawable *pdp)
+{
+    __DRIscreen *psp = pdp->driScreenPriv;
+    __DRIcontext *pcp = pdp->driContextPriv;
+    
+    if (!pcp 
+	|| ((pdp != pcp->driDrawablePriv) && (pdp != pcp->driReadablePriv))) {
+	/* ERROR!!! 
+	 * ...but we must ignore it. There can be many contexts bound to a
+	 * drawable.
+	 */
+    }
+
+    if (pdp->pClipRects) {
+	free(pdp->pClipRects); 
+	pdp->pClipRects = NULL;
+    }
+
+    if (pdp->pBackClipRects) {
+	free(pdp->pBackClipRects); 
+	pdp->pBackClipRects = NULL;
+    }
+
+    DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+
+    if (! (*psp->getDrawableInfo->getDrawableInfo)(pdp,
+			  &pdp->index, &pdp->lastStamp,
+			  &pdp->x, &pdp->y, &pdp->w, &pdp->h,
+			  &pdp->numClipRects, &pdp->pClipRects,
+			  &pdp->backX,
+			  &pdp->backY,
+			  &pdp->numBackClipRects,
+			  &pdp->pBackClipRects,
+			  pdp->loaderPrivate)) {
+	/* Error -- eg the window may have been destroyed.  Keep going
+	 * with no cliprects.
+	 */
+        pdp->pStamp = &pdp->lastStamp; /* prevent endless loop */
+	pdp->numClipRects = 0;
+	pdp->pClipRects = NULL;
+	pdp->numBackClipRects = 0;
+	pdp->pBackClipRects = NULL;
+    }
+    else
+       pdp->pStamp = &(psp->pSAREA->drawableTable[pdp->index].stamp);
+
+    DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);
+}
+
+/*@}*/
+
+/*****************************************************************/
+/** \name GLX callbacks                                          */
+/*****************************************************************/
+/*@{*/
+
+static void driReportDamage(__DRIdrawable *pdp,
+			    struct drm_clip_rect *pClipRects, int numClipRects)
+{
+    __DRIscreen *psp = pdp->driScreenPriv;
+
+    /* Check that we actually have the new damage report method */
+    if (psp->damage) {
+	/* Report the damage.  Currently, all our drivers draw
+	 * directly to the front buffer, so we report the damage there
+	 * rather than to the backing storein (if any).
+	 */
+	(*psp->damage->reportDamage)(pdp,
+				     pdp->x, pdp->y,
+				     pClipRects, numClipRects,
+				     GL_TRUE, pdp->loaderPrivate);
+    }
+}
+
+
+/**
+ * Swap buffers.
+ *
+ * \param drawablePrivate opaque pointer to the per-drawable private info.
+ * 
+ * \internal
+ * This function calls __DRIdrawable::swapBuffers.
+ * 
+ * Is called directly from glXSwapBuffers().
+ */
+static void driSwapBuffers(__DRIdrawable *dPriv)
+{
+    __DRIscreen *psp = dPriv->driScreenPriv;
+    drm_clip_rect_t *rects;
+    int i;
+
+    psp->DriverAPI.SwapBuffers(dPriv);
+
+    if (!dPriv->numClipRects)
+        return;
+
+    rects = malloc(sizeof(*rects) * dPriv->numClipRects);
+
+    if (!rects)
+        return;
+
+    for (i = 0; i < dPriv->numClipRects; i++) {
+        rects[i].x1 = dPriv->pClipRects[i].x1 - dPriv->x;
+        rects[i].y1 = dPriv->pClipRects[i].y1 - dPriv->y;
+        rects[i].x2 = dPriv->pClipRects[i].x2 - dPriv->x;
+        rects[i].y2 = dPriv->pClipRects[i].y2 - dPriv->y;
+    }
+
+    driReportDamage(dPriv, rects, dPriv->numClipRects);
+    free(rects);
+}
+
+static int driDrawableGetMSC( __DRIscreen *sPriv, __DRIdrawable *dPriv,
+			      int64_t *msc )
+{
+    return sPriv->DriverAPI.GetDrawableMSC(sPriv, dPriv, msc);
+}
+
+
+static int driWaitForMSC(__DRIdrawable *dPriv, int64_t target_msc,
+			 int64_t divisor, int64_t remainder,
+			 int64_t * msc, int64_t * sbc)
+{
+    __DRIswapInfo  sInfo;
+    int  status;
+
+    status = dPriv->driScreenPriv->DriverAPI.WaitForMSC( dPriv, target_msc,
+                                                         divisor, remainder,
+                                                         msc );
+
+    /* GetSwapInfo() may not be provided by the driver if GLX_SGI_video_sync
+     * is supported but GLX_OML_sync_control is not.  Therefore, don't return
+     * an error value if GetSwapInfo() is not implemented.
+    */
+    if ( status == 0
+         && dPriv->driScreenPriv->DriverAPI.GetSwapInfo ) {
+        status = dPriv->driScreenPriv->DriverAPI.GetSwapInfo( dPriv, & sInfo );
+        *sbc = sInfo.swap_count;
+    }
+
+    return status;
+}
+
+
+const __DRImediaStreamCounterExtension driMediaStreamCounterExtension = {
+    { __DRI_MEDIA_STREAM_COUNTER, __DRI_MEDIA_STREAM_COUNTER_VERSION },
+    driWaitForMSC,
+    driDrawableGetMSC,
+};
+
+
+static void driCopySubBuffer(__DRIdrawable *dPriv,
+			      int x, int y, int w, int h)
+{
+    drm_clip_rect_t rect;
+
+    rect.x1 = x;
+    rect.y1 = dPriv->h - y - h;
+    rect.x2 = x + w;
+    rect.y2 = rect.y1 + h;
+    driReportDamage(dPriv, &rect, 1);
+
+    dPriv->driScreenPriv->DriverAPI.CopySubBuffer(dPriv, x, y, w, h);
+}
+
+const __DRIcopySubBufferExtension driCopySubBufferExtension = {
+    { __DRI_COPY_SUB_BUFFER, __DRI_COPY_SUB_BUFFER_VERSION },
+    driCopySubBuffer
+};
+
+static void driSetSwapInterval(__DRIdrawable *dPriv, unsigned int interval)
+{
+    dPriv->swap_interval = interval;
+}
+
+static unsigned int driGetSwapInterval(__DRIdrawable *dPriv)
+{
+    return dPriv->swap_interval;
+}
+
+const __DRIswapControlExtension driSwapControlExtension = {
+    { __DRI_SWAP_CONTROL, __DRI_SWAP_CONTROL_VERSION },
+    driSetSwapInterval,
+    driGetSwapInterval
+};
+
+
+/**
+ * This is called via __DRIscreenRec's createNewDrawable pointer.
+ */
+static __DRIdrawable *
+driCreateNewDrawable(__DRIscreen *psp, const __DRIconfig *config,
+		     drm_drawable_t hwDrawable, int renderType,
+		     const int *attrs, void *data)
+{
+    __DRIdrawable *pdp;
+
+    /* Since pbuffers are not yet supported, no drawable attributes are
+     * supported either.
+     */
+    (void) attrs;
+    (void) renderType;
+
+    pdp = malloc(sizeof *pdp);
+    if (!pdp) {
+	return NULL;
+    }
+
+    pdp->driContextPriv = NULL;
+    pdp->loaderPrivate = data;
+    pdp->hHWDrawable = hwDrawable;
+    pdp->refcount = 1;
+    pdp->pStamp = NULL;
+    pdp->lastStamp = 0;
+    pdp->index = 0;
+    pdp->x = 0;
+    pdp->y = 0;
+    pdp->w = 0;
+    pdp->h = 0;
+    pdp->numClipRects = 0;
+    pdp->numBackClipRects = 0;
+    pdp->pClipRects = NULL;
+    pdp->pBackClipRects = NULL;
+    pdp->vblSeq = 0;
+    pdp->vblFlags = 0;
+
+    pdp->driScreenPriv = psp;
+
+    if (!(*psp->DriverAPI.CreateBuffer)(psp, pdp, &config->modes, 0)) {
+       free(pdp);
+       return NULL;
+    }
+
+    pdp->msc_base = 0;
+
+    /* This special default value is replaced with the configured
+     * default value when the drawable is first bound to a direct
+     * rendering context. 
+     */
+    pdp->swap_interval = (unsigned)-1;
+
+    return pdp;
+}
+
+
+static __DRIdrawable *
+dri2CreateNewDrawable(__DRIscreen *screen,
+		      const __DRIconfig *config,
+		      void *loaderPrivate)
+{
+    __DRIdrawable *pdraw;
+
+    pdraw = driCreateNewDrawable(screen, config, 0, 0, NULL, loaderPrivate);
+    if (!pdraw)
+    	return NULL;
+
+    pdraw->pClipRects = &pdraw->dri2.clipRect;
+    pdraw->pBackClipRects = &pdraw->dri2.clipRect;
+
+    pdraw->pStamp = &pdraw->dri2.stamp;
+    *pdraw->pStamp = pdraw->lastStamp + 1;
+
+    return pdraw;
+}
+
+static __DRIbuffer *
+dri2AllocateBuffer(__DRIscreen *screen,
+		   unsigned int attachment, unsigned int format,
+		   int width, int height)
+{
+    return (*screen->DriverAPI.AllocateBuffer)(screen, attachment, format,
+					       width, height);
+}
+
+static void
+dri2ReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)
+{
+   (*screen->DriverAPI.ReleaseBuffer)(screen, buffer);
+}
+
+
+static int
+dri2ConfigQueryb(__DRIscreen *screen, const char *var, GLboolean *val)
+{
+   if (!driCheckOption(&screen->optionCache, var, DRI_BOOL))
+      return -1;
+
+   *val = driQueryOptionb(&screen->optionCache, var);
+
+   return 0;
+}
+
+static int
+dri2ConfigQueryi(__DRIscreen *screen, const char *var, GLint *val)
+{
+   if (!driCheckOption(&screen->optionCache, var, DRI_INT) &&
+       !driCheckOption(&screen->optionCache, var, DRI_ENUM))
+      return -1;
+
+    *val = driQueryOptioni(&screen->optionCache, var);
+
+    return 0;
+}
+
+static int
+dri2ConfigQueryf(__DRIscreen *screen, const char *var, GLfloat *val)
+{
+   if (!driCheckOption(&screen->optionCache, var, DRI_FLOAT))
+      return -1;
+
+    *val = driQueryOptionf(&screen->optionCache, var);
+
+    return 0;
+}
+
+
+static void dri_get_drawable(__DRIdrawable *pdp)
+{
+    pdp->refcount++;
+}
+	
+static void dri_put_drawable(__DRIdrawable *pdp)
+{
+    __DRIscreen *psp;
+
+    if (pdp) {
+	pdp->refcount--;
+	if (pdp->refcount)
+	    return;
+
+	psp = pdp->driScreenPriv;
+        (*psp->DriverAPI.DestroyBuffer)(pdp);
+	if (pdp->pClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {
+	    free(pdp->pClipRects);
+	    pdp->pClipRects = NULL;
+	}
+	if (pdp->pBackClipRects && pdp->pClipRects != &pdp->dri2.clipRect) {
+	    free(pdp->pBackClipRects);
+	    pdp->pBackClipRects = NULL;
+	}
+	free(pdp);
+    }
+}
+
+static void
+driDestroyDrawable(__DRIdrawable *pdp)
+{
+    dri_put_drawable(pdp);
+}
+
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Context handling functions                             */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Destroy the per-context private information.
+ * 
+ * \internal
+ * This function calls __DriverAPIRec::DestroyContext on \p contextPrivate, calls
+ * drmDestroyContext(), and finally frees \p contextPrivate.
+ */
+static void
+driDestroyContext(__DRIcontext *pcp)
+{
+    if (pcp) {
+	(*pcp->driScreenPriv->DriverAPI.DestroyContext)(pcp);
+	free(pcp);
+    }
+}
+
+
+/**
+ * Create the per-drawable private driver information.
+ * 
+ * \param render_type   Type of rendering target.  \c GLX_RGBA_TYPE is the only
+ *                      type likely to ever be supported for direct-rendering.
+ *                      However, \c GLX_RGBA_FLOAT_TYPE_ARB may eventually be
+ *                      supported by some drivers.
+ * \param shared        Context with which to share textures, etc. or NULL
+ *
+ * \returns An opaque pointer to the per-context private information on
+ *          success, or \c NULL on failure.
+ * 
+ * \internal
+ * This function allocates and fills a __DRIcontextRec structure.  It
+ * performs some device independent initialization and passes all the
+ * relevent information to __DriverAPIRec::CreateContext to create the
+ * context.
+ *
+ */
+static __DRIcontext *
+driCreateNewContext(__DRIscreen *psp, const __DRIconfig *config,
+		    int render_type, __DRIcontext *shared, 
+		    drm_context_t hwContext, void *data)
+{
+    __DRIcontext *pcp;
+    void * const shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
+
+    (void) render_type;
+
+    pcp = malloc(sizeof *pcp);
+    if (!pcp)
+	return NULL;
+
+    pcp->driScreenPriv = psp;
+    pcp->driDrawablePriv = NULL;
+    pcp->loaderPrivate = data;
+    
+    pcp->dri2.draw_stamp = 0;
+    pcp->dri2.read_stamp = 0;
+
+    pcp->hHWContext = hwContext;
+
+    if ( !(*psp->DriverAPI.CreateContext)(API_OPENGL,
+					  &config->modes, pcp, shareCtx) ) {
+        free(pcp);
+        return NULL;
+    }
+
+    return pcp;
+}
+
+static unsigned int
+dri2GetAPIMask(__DRIscreen *screen)
+{
+    return screen->api_mask;
+}
+
+static __DRIcontext *
+dri2CreateNewContextForAPI(__DRIscreen *screen, int api,
+			   const __DRIconfig *config,
+			   __DRIcontext *shared, void *data)
+{
+    __DRIcontext *context;
+    const struct gl_config *modes = (config != NULL) ? &config->modes : NULL;
+    void *shareCtx = (shared != NULL) ? shared->driverPrivate : NULL;
+    gl_api mesa_api;
+
+    if (!(screen->api_mask & (1 << api)))
+	return NULL;
+
+    switch (api) {
+    case __DRI_API_OPENGL:
+	    mesa_api = API_OPENGL;
+	    break;
+    case __DRI_API_GLES:
+	    mesa_api = API_OPENGLES;
+	    break;
+    case __DRI_API_GLES2:
+	    mesa_api = API_OPENGLES2;
+	    break;
+    default:
+	    return NULL;
+    }
+
+    context = malloc(sizeof *context);
+    if (!context)
+	return NULL;
+
+    context->driScreenPriv = screen;
+    context->driDrawablePriv = NULL;
+    context->loaderPrivate = data;
+    
+    if (!(*screen->DriverAPI.CreateContext)(mesa_api, modes,
+					    context, shareCtx) ) {
+        free(context);
+        return NULL;
+    }
+
+    return context;
+}
+
+
+static __DRIcontext *
+dri2CreateNewContext(__DRIscreen *screen, const __DRIconfig *config,
+		      __DRIcontext *shared, void *data)
+{
+   return dri2CreateNewContextForAPI(screen, __DRI_API_OPENGL,
+				     config, shared, data);
+}
+
+static int
+driCopyContext(__DRIcontext *dest, __DRIcontext *src, unsigned long mask)
+{
+    (void) dest;
+    (void) src;
+    (void) mask;
+    return GL_FALSE;
+}
+
+/*@}*/
+
+
+/*****************************************************************/
+/** \name Screen handling functions                              */
+/*****************************************************************/
+/*@{*/
+
+/**
+ * Destroy the per-screen private information.
+ * 
+ * \internal
+ * This function calls __DriverAPIRec::DestroyScreen on \p screenPrivate, calls
+ * drmClose(), and finally frees \p screenPrivate.
+ */
+static void driDestroyScreen(__DRIscreen *psp)
+{
+    if (psp) {
+	/* No interaction with the X-server is possible at this point.  This
+	 * routine is called after XCloseDisplay, so there is no protocol
+	 * stream open to the X-server anymore.
+	 */
+
+       _mesa_destroy_shader_compiler();
+
+	if (psp->DriverAPI.DestroyScreen)
+	    (*psp->DriverAPI.DestroyScreen)(psp);
+
+	if (!psp->dri2.enabled) {
+	   (void)drmUnmap((drmAddress)psp->pSAREA, SAREA_MAX);
+	   (void)drmUnmap((drmAddress)psp->pFB, psp->fbSize);
+	   (void)drmCloseOnce(psp->fd);
+	} else {
+	   driDestroyOptionCache(&psp->optionCache);
+	   driDestroyOptionInfo(&psp->optionInfo);
+	}
+
+	free(psp);
+    }
+}
+
+static void
+setupLoaderExtensions(__DRIscreen *psp,
+		      const __DRIextension **extensions)
+{
+    int i;
+
+    for (i = 0; extensions[i]; i++) {
+	if (strcmp(extensions[i]->name, __DRI_GET_DRAWABLE_INFO) == 0)
+	    psp->getDrawableInfo = (__DRIgetDrawableInfoExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_DAMAGE) == 0)
+	    psp->damage = (__DRIdamageExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_SYSTEM_TIME) == 0)
+	    psp->systemTime = (__DRIsystemTimeExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_DRI2_LOADER) == 0)
+	    psp->dri2.loader = (__DRIdri2LoaderExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_IMAGE_LOOKUP) == 0)
+	    psp->dri2.image = (__DRIimageLookupExtension *) extensions[i];
+	if (strcmp(extensions[i]->name, __DRI_USE_INVALIDATE) == 0)
+	    psp->dri2.useInvalidate = (__DRIuseInvalidateExtension *) extensions[i];
+    }
+}
+
+/**
+ * This is the bootstrap function for the driver.  libGL supplies all of the
+ * requisite information about the system, and the driver initializes itself.
+ * This routine also fills in the linked list pointed to by \c driver_modes
+ * with the \c struct gl_config that the driver can support for windows or
+ * pbuffers.
+ *
+ * For legacy DRI.
+ * 
+ * \param scrn  Index of the screen
+ * \param ddx_version Version of the 2D DDX.  This may not be meaningful for
+ *                    all drivers.
+ * \param dri_version Version of the "server-side" DRI.
+ * \param drm_version Version of the kernel DRM.
+ * \param frame_buffer Data describing the location and layout of the
+ *                     framebuffer.
+ * \param pSAREA       Pointer to the SAREA.
+ * \param fd           Device handle for the DRM.
+ * \param extensions   ??
+ * \param driver_modes  Returns modes suppoted by the driver
+ * \param loaderPrivate  ??
+ * 
+ * \note There is no need to check the minimum API version in this
+ * function.  Since the name of this function is versioned, it is
+ * impossible for a loader that is too old to even load this driver.
+ */
+static __DRIscreen *
+driCreateNewScreen(int scrn,
+		   const __DRIversion *ddx_version,
+		   const __DRIversion *dri_version,
+		   const __DRIversion *drm_version,
+		   const __DRIframebuffer *frame_buffer,
+		   drmAddress pSAREA, int fd, 
+		   const __DRIextension **extensions,
+		   const __DRIconfig ***driver_modes,
+		   void *loaderPrivate)
+{
+    static const __DRIextension *emptyExtensionList[] = { NULL };
+    __DRIscreen *psp;
+
+    (void) loaderPrivate;
+
+    if (driDriverAPI.InitScreen == NULL)
+	return NULL;
+
+    psp = calloc(1, sizeof *psp);
+    if (!psp)
+	return NULL;
+
+    setupLoaderExtensions(psp, extensions);
+
+    /*
+    ** NOT_DONE: This is used by the X server to detect when the client
+    ** has died while holding the drawable lock.  The client sets the
+    ** drawable lock to this value.
+    */
+    psp->drawLockID = 1;
+
+    psp->drm_version = *drm_version;
+    psp->ddx_version = *ddx_version;
+    psp->dri_version = *dri_version;
+
+    psp->pSAREA = pSAREA;
+    psp->lock = (drmLock *) &psp->pSAREA->lock;
+
+    psp->pFB = frame_buffer->base;
+    psp->fbSize = frame_buffer->size;
+    psp->fbStride = frame_buffer->stride;
+    psp->fbWidth = frame_buffer->width;
+    psp->fbHeight = frame_buffer->height;
+    psp->devPrivSize = frame_buffer->dev_priv_size;
+    psp->pDevPriv = frame_buffer->dev_priv;
+    psp->fbBPP = psp->fbStride * 8 / frame_buffer->width;
+
+    psp->extensions = emptyExtensionList;
+    psp->fd = fd;
+    psp->myNum = scrn;
+    psp->dri2.enabled = GL_FALSE;
+
+    psp->DriverAPI = driDriverAPI;
+    psp->api_mask = (1 << __DRI_API_OPENGL);
+
+    *driver_modes = driDriverAPI.InitScreen(psp);
+    if (*driver_modes == NULL) {
+	free(psp);
+	return NULL;
+    }
+
+    return psp;
+}
+
+/**
+ * DRI2
+ */
+static __DRIscreen *
+dri2CreateNewScreen(int scrn, int fd,
+		    const __DRIextension **extensions,
+		    const __DRIconfig ***driver_configs, void *data)
+{
+    static const __DRIextension *emptyExtensionList[] = { NULL };
+    __DRIscreen *psp;
+    drmVersionPtr version;
+
+    if (driDriverAPI.InitScreen2 == NULL)
+        return NULL;
+
+    psp = calloc(1, sizeof(*psp));
+    if (!psp)
+	return NULL;
+
+    setupLoaderExtensions(psp, extensions);
+
+    version = drmGetVersion(fd);
+    if (version) {
+	psp->drm_version.major = version->version_major;
+	psp->drm_version.minor = version->version_minor;
+	psp->drm_version.patch = version->version_patchlevel;
+	drmFreeVersion(version);
+    }
+
+    psp->extensions = emptyExtensionList;
+    psp->fd = fd;
+    psp->myNum = scrn;
+    psp->dri2.enabled = GL_TRUE;
+
+    psp->DriverAPI = driDriverAPI;
+    psp->api_mask = (1 << __DRI_API_OPENGL);
+    *driver_configs = driDriverAPI.InitScreen2(psp);
+    if (*driver_configs == NULL) {
+	free(psp);
+	return NULL;
+    }
+
+    psp->DriverAPI = driDriverAPI;
+    psp->loaderPrivate = data;
+
+    driParseOptionInfo(&psp->optionInfo, __dri2ConfigOptions,
+		       __dri2NConfigOptions);
+    driParseConfigFiles(&psp->optionCache, &psp->optionInfo, psp->myNum,
+			"dri2");
+
+    return psp;
+}
+
+static const __DRIextension **driGetExtensions(__DRIscreen *psp)
+{
+    return psp->extensions;
+}
+
+/** Core interface */
+const __DRIcoreExtension driCoreExtension = {
+    { __DRI_CORE, __DRI_CORE_VERSION },
+    NULL,
+    driDestroyScreen,
+    driGetExtensions,
+    driGetConfigAttrib,
+    driIndexConfigAttrib,
+    NULL,
+    driDestroyDrawable,
+    driSwapBuffers,
+    NULL,
+    driCopyContext,
+    driDestroyContext,
+    driBindContext,
+    driUnbindContext
+};
+
+/** Legacy DRI interface */
+const __DRIlegacyExtension driLegacyExtension = {
+    { __DRI_LEGACY, __DRI_LEGACY_VERSION },
+    driCreateNewScreen,
+    driCreateNewDrawable,
+    driCreateNewContext,
+};
+
+/** DRI2 interface */
+const __DRIdri2Extension driDRI2Extension = {
+    { __DRI_DRI2, __DRI_DRI2_VERSION },
+    dri2CreateNewScreen,
+    dri2CreateNewDrawable,
+    dri2CreateNewContext,
+    dri2GetAPIMask,
+    dri2CreateNewContextForAPI,
+    dri2AllocateBuffer,
+    dri2ReleaseBuffer
+};
+
+const __DRI2configQueryExtension dri2ConfigQueryExtension = {
+   { __DRI2_CONFIG_QUERY, __DRI2_CONFIG_QUERY_VERSION },
+   dri2ConfigQueryb,
+   dri2ConfigQueryi,
+   dri2ConfigQueryf,
+};
+
+/**
+ * Calculate amount of swap interval used between GLX buffer swaps.
+ * 
+ * The usage value, on the range [0,max], is the fraction of total swap
+ * interval time used between GLX buffer swaps is calculated.
+ *
+ *            \f$p = t_d / (i * t_r)\f$
+ * 
+ * Where \f$t_d\f$ is the time since the last GLX buffer swap, \f$i\f$ is the
+ * swap interval (as set by \c glXSwapIntervalSGI), and \f$t_r\f$ time
+ * required for a single vertical refresh period (as returned by \c
+ * glXGetMscRateOML).
+ * 
+ * See the documentation for the GLX_MESA_swap_frame_usage extension for more
+ * details.
+ *
+ * \param   dPriv  Pointer to the private drawable structure.
+ * \return  If less than a single swap interval time period was required
+ *          between GLX buffer swaps, a number greater than 0 and less than
+ *          1.0 is returned.  If exactly one swap interval time period is
+ *          required, 1.0 is returned, and if more than one is required then
+ *          a number greater than 1.0 will be returned.
+ *
+ * \sa glXSwapIntervalSGI glXGetMscRateOML
+ * 
+ * \todo Instead of caching the \c glXGetMscRateOML function pointer, would it
+ *       be possible to cache the sync rate?
+ */
+float
+driCalculateSwapUsage( __DRIdrawable *dPriv, int64_t last_swap_ust,
+		       int64_t current_ust )
+{
+   int32_t   n;
+   int32_t   d;
+   int       interval;
+   float     usage = 1.0;
+   __DRIscreen *psp = dPriv->driScreenPriv;
+
+   if ( (*psp->systemTime->getMSCRate)(dPriv, &n, &d, dPriv->loaderPrivate) ) {
+      interval = (dPriv->swap_interval != 0) ? dPriv->swap_interval : 1;
+
+
+      /* We want to calculate
+       * (current_UST - last_swap_UST) / (interval * us_per_refresh).  We get
+       * current_UST by calling __glXGetUST.  last_swap_UST is stored in
+       * dPriv->swap_ust.  interval has already been calculated.
+       *
+       * The only tricky part is us_per_refresh.  us_per_refresh is
+       * 1000000 / MSC_rate.  We know the MSC_rate is n / d.  We can flip it
+       * around and say us_per_refresh = 1000000 * d / n.  Since this goes in
+       * the denominator of the final calculation, we calculate
+       * (interval * 1000000 * d) and move n into the numerator.
+       */
+
+      usage = (current_ust - last_swap_ust);
+      usage *= n;
+      usage /= (interval * d);
+      usage /= 1000000.0;
+   }
+   
+   return usage;
+}
+
+void
+dri2InvalidateDrawable(__DRIdrawable *drawable)
+{
+    drawable->dri2.stamp++;
+}
+
+/*@}*/
diff --git a/mesalib/src/mesa/drivers/dri/common/dri_util.h b/mesalib/src/mesa/drivers/dri/common/dri_util.h
index 8d2a38524..3d3d5c9cd 100644
--- a/mesalib/src/mesa/drivers/dri/common/dri_util.h
+++ b/mesalib/src/mesa/drivers/dri/common/dri_util.h
@@ -1,563 +1,563 @@
-/*

- * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.

- * All Rights Reserved.

- * 

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the

- * "Software"), to deal in the Software without restriction, including

- * without limitation the rights to use, copy, modify, merge, publish,

- * distribute, sub license, and/or sell copies of the Software, and to

- * permit persons to whom the Software is furnished to do so, subject to

- * the following conditions:

- * 

- * The above copyright notice and this permission notice (including the

- * next paragraph) shall be included in all copies or substantial portions

- * of the Software.

- * 

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.

- * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR

- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- */

-

-/**

- * \file dri_util.h

- * DRI utility functions definitions.

- *

- * This module acts as glue between GLX and the actual hardware driver.  A DRI

- * driver doesn't really \e have to use any of this - it's optional.  But, some

- * useful stuff is done here that otherwise would have to be duplicated in most

- * drivers.

- * 

- * Basically, these utility functions take care of some of the dirty details of

- * screen initialization, context creation, context binding, DRM setup, etc.

- *

- * These functions are compiled into each DRI driver so libGL.so knows nothing

- * about them.

- *

- * \sa dri_util.c.

- * 

- * \author Kevin E. Martin <kevin@precisioninsight.com>

- * \author Brian Paul <brian@precisioninsight.com>

- */

-

-#ifndef _DRI_UTIL_H_

-#define _DRI_UTIL_H_

-

-#include <GL/gl.h>

-#include <drm.h>

-#include <drm_sarea.h>

-#include <xf86drm.h>

-#include "xmlconfig.h"

-#include "main/glheader.h"

-#include "main/mtypes.h"

-#include "GL/internal/dri_interface.h"

-

-#define GLX_BAD_CONTEXT                    5

-

-typedef struct __DRIswapInfoRec        __DRIswapInfo;

-

-/**

- * Extensions.

- */

-extern const __DRIlegacyExtension driLegacyExtension;

-extern const __DRIcoreExtension driCoreExtension;

-extern const __DRIdri2Extension driDRI2Extension;

-extern const __DRIextension driReadDrawableExtension;

-extern const __DRIcopySubBufferExtension driCopySubBufferExtension;

-extern const __DRIswapControlExtension driSwapControlExtension;

-extern const __DRImediaStreamCounterExtension driMediaStreamCounterExtension;

-extern const __DRI2configQueryExtension dri2ConfigQueryExtension;

-

-/**

- * Used by DRI_VALIDATE_DRAWABLE_INFO

- */

-#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \

-    do {                                                        \

-	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \

-	    __driUtilUpdateDrawableInfo(pDrawPriv);             \

-	}                                                       \

-    } while (0)

-

-

-/**

- * Utility macro to validate the drawable information.

- *

- * See __DRIdrawable::pStamp and __DRIdrawable::lastStamp.

- */

-#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \

-do {                                                                    \

-    while (*(pdp->pStamp) != pdp->lastStamp) {                          \

-        register unsigned int hwContext = psp->pSAREA->lock.lock &      \

-		     ~(DRM_LOCK_HELD | DRM_LOCK_CONT);                  \

-	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock, hwContext);             \

-                                                                        \

-	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \

-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \

-	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \

-                                                                        \

-	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock, hwContext);         \

-    }                                                                   \

-} while (0)

-

-/**

- * Same as above, but for two drawables simultaneously.

- *

- */

-

-#define DRI_VALIDATE_TWO_DRAWABLES_INFO(psp, pdp, prp)			\

-do {								\

-    while (*((pdp)->pStamp) != (pdp)->lastStamp ||			\

-	   *((prp)->pStamp) != (prp)->lastStamp) {			\

-        register unsigned int hwContext = (psp)->pSAREA->lock.lock &	\

-	    ~(DRM_LOCK_HELD | DRM_LOCK_CONT);				\

-	DRM_UNLOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);		\

-									\

-	DRM_SPINLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID);	\

-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \

-	DRI_VALIDATE_DRAWABLE_INFO_ONCE(prp);				\

-	DRM_SPINUNLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID); \

-									\

-	DRM_LIGHT_LOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);	\

-    }                                                                   \

-} while (0)

-

-

-/**

- * Driver callback functions.

- *

- * Each DRI driver must have one of these structures with all the pointers set

- * to appropriate functions within the driver.

- * 

- * When glXCreateContext() is called, for example, it'll call a helper function

- * dri_util.c which in turn will jump through the \a CreateContext pointer in

- * this structure.

- */

-struct __DriverAPIRec {

-    const __DRIconfig **(*InitScreen) (__DRIscreen * priv);

-

-    /**

-     * Screen destruction callback

-     */

-    void (*DestroyScreen)(__DRIscreen *driScrnPriv);

-

-    /**

-     * Context creation callback

-     */	    	    

-    GLboolean (*CreateContext)(gl_api api,

-			       const struct gl_config *glVis,

-			       __DRIcontext *driContextPriv,

-                               void *sharedContextPrivate);

-

-    /**

-     * Context destruction callback

-     */

-    void (*DestroyContext)(__DRIcontext *driContextPriv);

-

-    /**

-     * Buffer (drawable) creation callback

-     */

-    GLboolean (*CreateBuffer)(__DRIscreen *driScrnPriv,

-                              __DRIdrawable *driDrawPriv,

-                              const struct gl_config *glVis,

-                              GLboolean pixmapBuffer);

-    

-    /**

-     * Buffer (drawable) destruction callback

-     */

-    void (*DestroyBuffer)(__DRIdrawable *driDrawPriv);

-

-    /**

-     * Buffer swapping callback 

-     */

-    void (*SwapBuffers)(__DRIdrawable *driDrawPriv);

-

-    /**

-     * Context activation callback

-     */

-    GLboolean (*MakeCurrent)(__DRIcontext *driContextPriv,

-                             __DRIdrawable *driDrawPriv,

-                             __DRIdrawable *driReadPriv);

-

-    /**

-     * Context unbinding callback

-     */

-    GLboolean (*UnbindContext)(__DRIcontext *driContextPriv);

-  

-    /**

-     * Retrieves statistics about buffer swap operations.  Required if

-     * GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.

-     */

-    int (*GetSwapInfo)( __DRIdrawable *dPriv, __DRIswapInfo * sInfo );

-

-

-    /**

-     * These are required if GLX_OML_sync_control is supported.

-     */

-    /*@{*/

-    int (*WaitForMSC)( __DRIdrawable *priv, int64_t target_msc, 

-		       int64_t divisor, int64_t remainder,

-		       int64_t * msc );

-    int (*WaitForSBC)( __DRIdrawable *priv, int64_t target_sbc,

-		       int64_t * msc, int64_t * sbc );

-

-    int64_t (*SwapBuffersMSC)( __DRIdrawable *priv, int64_t target_msc,

-			       int64_t divisor, int64_t remainder );

-    /*@}*/

-    void (*CopySubBuffer)(__DRIdrawable *driDrawPriv,

-			  int x, int y, int w, int h);

-

-    /**

-     * New version of GetMSC so we can pass drawable data to the low

-     * level DRM driver (e.g. pipe info).  Required if

-     * GLX_SGI_video_sync or GLX_OML_sync_control is supported.

-     */

-    int (*GetDrawableMSC) ( __DRIscreen * priv,

-			    __DRIdrawable *drawablePrivate,

-			    int64_t *count);

-

-

-

-    /* DRI2 Entry point */

-    const __DRIconfig **(*InitScreen2) (__DRIscreen * priv);

-

-    __DRIbuffer *(*AllocateBuffer) (__DRIscreen *screenPrivate,

-				    unsigned int attachment,

-				    unsigned int format,

-				    int width, int height);

-    void (*ReleaseBuffer) (__DRIscreen *screenPrivate, __DRIbuffer *buffer);

-};

-

-extern const struct __DriverAPIRec driDriverAPI;

-

-

-struct __DRIswapInfoRec {

-    /** 

-     * Number of swapBuffers operations that have been *completed*. 

-     */

-    uint64_t swap_count;

-

-    /**

-     * Unadjusted system time of the last buffer swap.  This is the time

-     * when the swap completed, not the time when swapBuffers was called.

-     */

-    int64_t   swap_ust;

-

-    /**

-     * Number of swap operations that occurred after the swap deadline.  That

-     * is if a swap happens more than swap_interval frames after the previous

-     * swap, it has missed its deadline.  If swap_interval is 0, then the

-     * swap deadline is 1 frame after the previous swap.

-     */

-    uint64_t swap_missed_count;

-

-    /**

-     * Amount of time used by the last swap that missed its deadline.  This

-     * is calculated as (__glXGetUST() - swap_ust) / (swap_interval * 

-     * time_for_single_vrefresh)).  If the actual value of swap_interval is

-     * 0, then 1 is used instead.  If swap_missed_count is non-zero, this

-     * should be greater-than 1.0.

-     */

-    float     swap_missed_usage;

-};

-

-

-/**

- * Per-drawable private DRI driver information.

- */

-struct __DRIdrawableRec {

-    /**

-     * Kernel drawable handle

-     */

-    drm_drawable_t hHWDrawable;

-

-    /**

-     * Driver's private drawable information.  

-     *

-     * This structure is opaque.

-     */

-    void *driverPrivate;

-

-    /**

-     * Private data from the loader.  We just hold on to it and pass

-     * it back when calling into loader provided functions.

-     */

-    void *loaderPrivate;

-

-    /**

-     * Reference count for number of context's currently bound to this

-     * drawable.  

-     *

-     * Once it reaches zero, the drawable can be destroyed.

-     *

-     * \note This behavior will change with GLX 1.3.

-     */

-    int refcount;

-

-    /**

-     * Index of this drawable information in the SAREA.

-     */

-    unsigned int index;

-

-    /**

-     * Pointer to the "drawable has changed ID" stamp in the SAREA (or

-     * to dri2.stamp if DRI2 is being used).

-     */

-    unsigned int *pStamp;

-

-    /**

-     * Last value of the stamp.

-     *

-     * If this differs from the value stored at __DRIdrawable::pStamp,

-     * then the drawable information has been modified by the X server, and the

-     * drawable information (below) should be retrieved from the X server.

-     */

-    unsigned int lastStamp;

-

-    /**

-     * \name Drawable 

-     *

-     * Drawable information used in software fallbacks.

-     */

-    /*@{*/

-    int x;

-    int y;

-    int w;

-    int h;

-    int numClipRects;

-    drm_clip_rect_t *pClipRects;

-    /*@}*/

-

-    /**

-     * \name Back and depthbuffer

-     *

-     * Information about the back and depthbuffer where different from above.

-     */

-    /*@{*/

-    int backX;

-    int backY;

-    int backClipRectType;

-    int numBackClipRects;

-    drm_clip_rect_t *pBackClipRects;

-    /*@}*/

-

-    /**

-     * \name Vertical blank tracking information

-     * Used for waiting on vertical blank events.

-     */

-    /*@{*/

-    unsigned int vblSeq;

-    unsigned int vblFlags;

-    /*@}*/

-

-    /**

-     * \name Monotonic MSC tracking

-     *

-     * Low level driver is responsible for updating msc_base and

-     * vblSeq values so that higher level code can calculate

-     * a new msc value or msc target for a WaitMSC call.  The new value

-     * will be:

-     *   msc = msc_base + get_vblank_count() - vblank_base;

-     *

-     * And for waiting on a value, core code will use:

-     *   actual_target = target_msc - msc_base + vblank_base;

-     */

-    /*@{*/

-    int64_t vblank_base;

-    int64_t msc_base;

-    /*@}*/

-

-    /**

-     * Pointer to context to which this drawable is currently bound.

-     */

-    __DRIcontext *driContextPriv;

-

-    /**

-     * Pointer to screen on which this drawable was created.

-     */

-    __DRIscreen *driScreenPriv;

-

-    /**

-     * Controls swap interval as used by GLX_SGI_swap_control and

-     * GLX_MESA_swap_control.

-     */

-    unsigned int swap_interval;

-

-    struct {

-	unsigned int stamp;

-	drm_clip_rect_t clipRect;

-    } dri2;

-};

-

-/**

- * Per-context private driver information.

- */

-struct __DRIcontextRec {

-    /**

-     * Kernel context handle used to access the device lock.

-     */

-    drm_context_t hHWContext;

-

-    /**

-     * Device driver's private context data.  This structure is opaque.

-     */

-    void *driverPrivate;

-

-    /**

-     * Pointer to drawable currently bound to this context for drawing.

-     */

-    __DRIdrawable *driDrawablePriv;

-

-    /**

-     * Pointer to drawable currently bound to this context for reading.

-     */

-    __DRIdrawable *driReadablePriv;

-

-    /**

-     * Pointer to screen on which this context was created.

-     */

-    __DRIscreen *driScreenPriv;

-

-    /**

-     * The loaders's private context data.  This structure is opaque.

-     */

-    void *loaderPrivate;

-

-    struct {

-	int draw_stamp;

-	int read_stamp;

-    } dri2;

-};

-

-/**

- * Per-screen private driver information.

- */

-struct __DRIscreenRec {

-    /**

-     * Current screen's number

-     */

-    int myNum;

-

-    /**

-     * Callback functions into the hardware-specific DRI driver code.

-     */

-    struct __DriverAPIRec DriverAPI;

-

-    const __DRIextension **extensions;

-    /**

-     * DDX / 2D driver version information.

-     */

-    __DRIversion ddx_version;

-

-    /**

-     * DRI X extension version information.

-     */

-    __DRIversion dri_version;

-

-    /**

-     * DRM (kernel module) version information.

-     */

-    __DRIversion drm_version;

-

-    /**

-     * ID used when the client sets the drawable lock.

-     *

-     * The X server uses this value to detect if the client has died while

-     * holding the drawable lock.

-     */

-    int drawLockID;

-

-    /**

-     * File descriptor returned when the kernel device driver is opened.

-     * 

-     * Used to:

-     *   - authenticate client to kernel

-     *   - map the frame buffer, SAREA, etc.

-     *   - close the kernel device driver

-     */

-    int fd;

-

-    /**

-     * SAREA pointer 

-     *

-     * Used to access:

-     *   - the device lock

-     *   - the device-independent per-drawable and per-context(?) information

-     */

-    drm_sarea_t *pSAREA;

-

-    /**

-     * \name Direct frame buffer access information 

-     * Used for software fallbacks.

-     */

-    /*@{*/

-    unsigned char *pFB;

-    int fbSize;

-    int fbOrigin;

-    int fbStride;

-    int fbWidth;

-    int fbHeight;

-    int fbBPP;

-    /*@}*/

-

-    /**

-     * \name Device-dependent private information (stored in the SAREA).

-     *

-     * This data is accessed by the client driver only.

-     */

-    /*@{*/

-    void *pDevPriv;

-    int devPrivSize;

-    /*@}*/

-

-    /**

-     * Device-dependent private information (not stored in the SAREA).

-     * 

-     * This pointer is never touched by the DRI layer.

-     */

-#ifdef __cplusplus

-    void *priv;

-#else

-    void *private;

-#endif

-

-    /* Extensions provided by the loader. */

-    const __DRIgetDrawableInfoExtension *getDrawableInfo;

-    const __DRIsystemTimeExtension *systemTime;

-    const __DRIdamageExtension *damage;

-

-    struct {

-	/* Flag to indicate that this is a DRI2 screen.  Many of the above

-	 * fields will not be valid or initializaed in that case. */

-	int enabled;

-	__DRIdri2LoaderExtension *loader;

-	__DRIimageLookupExtension *image;

-	__DRIuseInvalidateExtension *useInvalidate;

-    } dri2;

-

-    /* The lock actually in use, old sarea or DRI2 */

-    drmLock *lock;

-

-    driOptionCache optionInfo;

-    driOptionCache optionCache;

-   unsigned int api_mask;

-   void *loaderPrivate;

-};

-

-extern void

-__driUtilUpdateDrawableInfo(__DRIdrawable *pdp);

-

-extern float

-driCalculateSwapUsage( __DRIdrawable *dPriv,

-		       int64_t last_swap_ust, int64_t current_ust );

-

-extern GLint

-driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 );

-

-extern void

-dri2InvalidateDrawable(__DRIdrawable *drawable);

-

-#endif /* _DRI_UTIL_H_ */

+/*
+ * Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
+ * All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sub license, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
+ * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file dri_util.h
+ * DRI utility functions definitions.
+ *
+ * This module acts as glue between GLX and the actual hardware driver.  A DRI
+ * driver doesn't really \e have to use any of this - it's optional.  But, some
+ * useful stuff is done here that otherwise would have to be duplicated in most
+ * drivers.
+ * 
+ * Basically, these utility functions take care of some of the dirty details of
+ * screen initialization, context creation, context binding, DRM setup, etc.
+ *
+ * These functions are compiled into each DRI driver so libGL.so knows nothing
+ * about them.
+ *
+ * \sa dri_util.c.
+ * 
+ * \author Kevin E. Martin <kevin@precisioninsight.com>
+ * \author Brian Paul <brian@precisioninsight.com>
+ */
+
+#ifndef _DRI_UTIL_H_
+#define _DRI_UTIL_H_
+
+#include <GL/gl.h>
+#include <drm.h>
+#include <drm_sarea.h>
+#include <xf86drm.h>
+#include "xmlconfig.h"
+#include "main/glheader.h"
+#include "main/mtypes.h"
+#include "GL/internal/dri_interface.h"
+
+#define GLX_BAD_CONTEXT                    5
+
+typedef struct __DRIswapInfoRec        __DRIswapInfo;
+
+/**
+ * Extensions.
+ */
+extern const __DRIlegacyExtension driLegacyExtension;
+extern const __DRIcoreExtension driCoreExtension;
+extern const __DRIdri2Extension driDRI2Extension;
+extern const __DRIextension driReadDrawableExtension;
+extern const __DRIcopySubBufferExtension driCopySubBufferExtension;
+extern const __DRIswapControlExtension driSwapControlExtension;
+extern const __DRImediaStreamCounterExtension driMediaStreamCounterExtension;
+extern const __DRI2configQueryExtension dri2ConfigQueryExtension;
+
+/**
+ * Used by DRI_VALIDATE_DRAWABLE_INFO
+ */
+#define DRI_VALIDATE_DRAWABLE_INFO_ONCE(pDrawPriv)              \
+    do {                                                        \
+	if (*(pDrawPriv->pStamp) != pDrawPriv->lastStamp) {     \
+	    __driUtilUpdateDrawableInfo(pDrawPriv);             \
+	}                                                       \
+    } while (0)
+
+
+/**
+ * Utility macro to validate the drawable information.
+ *
+ * See __DRIdrawable::pStamp and __DRIdrawable::lastStamp.
+ */
+#define DRI_VALIDATE_DRAWABLE_INFO(psp, pdp)                            \
+do {                                                                    \
+    while (*(pdp->pStamp) != pdp->lastStamp) {                          \
+        register unsigned int hwContext = psp->pSAREA->lock.lock &      \
+		     ~(DRM_LOCK_HELD | DRM_LOCK_CONT);                  \
+	DRM_UNLOCK(psp->fd, &psp->pSAREA->lock, hwContext);             \
+                                                                        \
+	DRM_SPINLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);     \
+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
+	DRM_SPINUNLOCK(&psp->pSAREA->drawable_lock, psp->drawLockID);   \
+                                                                        \
+	DRM_LIGHT_LOCK(psp->fd, &psp->pSAREA->lock, hwContext);         \
+    }                                                                   \
+} while (0)
+
+/**
+ * Same as above, but for two drawables simultaneously.
+ *
+ */
+
+#define DRI_VALIDATE_TWO_DRAWABLES_INFO(psp, pdp, prp)			\
+do {								\
+    while (*((pdp)->pStamp) != (pdp)->lastStamp ||			\
+	   *((prp)->pStamp) != (prp)->lastStamp) {			\
+        register unsigned int hwContext = (psp)->pSAREA->lock.lock &	\
+	    ~(DRM_LOCK_HELD | DRM_LOCK_CONT);				\
+	DRM_UNLOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);		\
+									\
+	DRM_SPINLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID);	\
+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(pdp);                           \
+	DRI_VALIDATE_DRAWABLE_INFO_ONCE(prp);				\
+	DRM_SPINUNLOCK(&(psp)->pSAREA->drawable_lock, (psp)->drawLockID); \
+									\
+	DRM_LIGHT_LOCK((psp)->fd, &(psp)->pSAREA->lock, hwContext);	\
+    }                                                                   \
+} while (0)
+
+
+/**
+ * Driver callback functions.
+ *
+ * Each DRI driver must have one of these structures with all the pointers set
+ * to appropriate functions within the driver.
+ * 
+ * When glXCreateContext() is called, for example, it'll call a helper function
+ * dri_util.c which in turn will jump through the \a CreateContext pointer in
+ * this structure.
+ */
+struct __DriverAPIRec {
+    const __DRIconfig **(*InitScreen) (__DRIscreen * priv);
+
+    /**
+     * Screen destruction callback
+     */
+    void (*DestroyScreen)(__DRIscreen *driScrnPriv);
+
+    /**
+     * Context creation callback
+     */	    	    
+    GLboolean (*CreateContext)(gl_api api,
+			       const struct gl_config *glVis,
+			       __DRIcontext *driContextPriv,
+                               void *sharedContextPrivate);
+
+    /**
+     * Context destruction callback
+     */
+    void (*DestroyContext)(__DRIcontext *driContextPriv);
+
+    /**
+     * Buffer (drawable) creation callback
+     */
+    GLboolean (*CreateBuffer)(__DRIscreen *driScrnPriv,
+                              __DRIdrawable *driDrawPriv,
+                              const struct gl_config *glVis,
+                              GLboolean pixmapBuffer);
+    
+    /**
+     * Buffer (drawable) destruction callback
+     */
+    void (*DestroyBuffer)(__DRIdrawable *driDrawPriv);
+
+    /**
+     * Buffer swapping callback 
+     */
+    void (*SwapBuffers)(__DRIdrawable *driDrawPriv);
+
+    /**
+     * Context activation callback
+     */
+    GLboolean (*MakeCurrent)(__DRIcontext *driContextPriv,
+                             __DRIdrawable *driDrawPriv,
+                             __DRIdrawable *driReadPriv);
+
+    /**
+     * Context unbinding callback
+     */
+    GLboolean (*UnbindContext)(__DRIcontext *driContextPriv);
+  
+    /**
+     * Retrieves statistics about buffer swap operations.  Required if
+     * GLX_OML_sync_control or GLX_MESA_swap_frame_usage is supported.
+     */
+    int (*GetSwapInfo)( __DRIdrawable *dPriv, __DRIswapInfo * sInfo );
+
+
+    /**
+     * These are required if GLX_OML_sync_control is supported.
+     */
+    /*@{*/
+    int (*WaitForMSC)( __DRIdrawable *priv, int64_t target_msc, 
+		       int64_t divisor, int64_t remainder,
+		       int64_t * msc );
+    int (*WaitForSBC)( __DRIdrawable *priv, int64_t target_sbc,
+		       int64_t * msc, int64_t * sbc );
+
+    int64_t (*SwapBuffersMSC)( __DRIdrawable *priv, int64_t target_msc,
+			       int64_t divisor, int64_t remainder );
+    /*@}*/
+    void (*CopySubBuffer)(__DRIdrawable *driDrawPriv,
+			  int x, int y, int w, int h);
+
+    /**
+     * New version of GetMSC so we can pass drawable data to the low
+     * level DRM driver (e.g. pipe info).  Required if
+     * GLX_SGI_video_sync or GLX_OML_sync_control is supported.
+     */
+    int (*GetDrawableMSC) ( __DRIscreen * priv,
+			    __DRIdrawable *drawablePrivate,
+			    int64_t *count);
+
+
+
+    /* DRI2 Entry point */
+    const __DRIconfig **(*InitScreen2) (__DRIscreen * priv);
+
+    __DRIbuffer *(*AllocateBuffer) (__DRIscreen *screenPrivate,
+				    unsigned int attachment,
+				    unsigned int format,
+				    int width, int height);
+    void (*ReleaseBuffer) (__DRIscreen *screenPrivate, __DRIbuffer *buffer);
+};
+
+extern const struct __DriverAPIRec driDriverAPI;
+
+
+struct __DRIswapInfoRec {
+    /** 
+     * Number of swapBuffers operations that have been *completed*. 
+     */
+    uint64_t swap_count;
+
+    /**
+     * Unadjusted system time of the last buffer swap.  This is the time
+     * when the swap completed, not the time when swapBuffers was called.
+     */
+    int64_t   swap_ust;
+
+    /**
+     * Number of swap operations that occurred after the swap deadline.  That
+     * is if a swap happens more than swap_interval frames after the previous
+     * swap, it has missed its deadline.  If swap_interval is 0, then the
+     * swap deadline is 1 frame after the previous swap.
+     */
+    uint64_t swap_missed_count;
+
+    /**
+     * Amount of time used by the last swap that missed its deadline.  This
+     * is calculated as (__glXGetUST() - swap_ust) / (swap_interval * 
+     * time_for_single_vrefresh)).  If the actual value of swap_interval is
+     * 0, then 1 is used instead.  If swap_missed_count is non-zero, this
+     * should be greater-than 1.0.
+     */
+    float     swap_missed_usage;
+};
+
+
+/**
+ * Per-drawable private DRI driver information.
+ */
+struct __DRIdrawableRec {
+    /**
+     * Kernel drawable handle
+     */
+    drm_drawable_t hHWDrawable;
+
+    /**
+     * Driver's private drawable information.  
+     *
+     * This structure is opaque.
+     */
+    void *driverPrivate;
+
+    /**
+     * Private data from the loader.  We just hold on to it and pass
+     * it back when calling into loader provided functions.
+     */
+    void *loaderPrivate;
+
+    /**
+     * Reference count for number of context's currently bound to this
+     * drawable.  
+     *
+     * Once it reaches zero, the drawable can be destroyed.
+     *
+     * \note This behavior will change with GLX 1.3.
+     */
+    int refcount;
+
+    /**
+     * Index of this drawable information in the SAREA.
+     */
+    unsigned int index;
+
+    /**
+     * Pointer to the "drawable has changed ID" stamp in the SAREA (or
+     * to dri2.stamp if DRI2 is being used).
+     */
+    unsigned int *pStamp;
+
+    /**
+     * Last value of the stamp.
+     *
+     * If this differs from the value stored at __DRIdrawable::pStamp,
+     * then the drawable information has been modified by the X server, and the
+     * drawable information (below) should be retrieved from the X server.
+     */
+    unsigned int lastStamp;
+
+    /**
+     * \name Drawable 
+     *
+     * Drawable information used in software fallbacks.
+     */
+    /*@{*/
+    int x;
+    int y;
+    int w;
+    int h;
+    int numClipRects;
+    drm_clip_rect_t *pClipRects;
+    /*@}*/
+
+    /**
+     * \name Back and depthbuffer
+     *
+     * Information about the back and depthbuffer where different from above.
+     */
+    /*@{*/
+    int backX;
+    int backY;
+    int backClipRectType;
+    int numBackClipRects;
+    drm_clip_rect_t *pBackClipRects;
+    /*@}*/
+
+    /**
+     * \name Vertical blank tracking information
+     * Used for waiting on vertical blank events.
+     */
+    /*@{*/
+    unsigned int vblSeq;
+    unsigned int vblFlags;
+    /*@}*/
+
+    /**
+     * \name Monotonic MSC tracking
+     *
+     * Low level driver is responsible for updating msc_base and
+     * vblSeq values so that higher level code can calculate
+     * a new msc value or msc target for a WaitMSC call.  The new value
+     * will be:
+     *   msc = msc_base + get_vblank_count() - vblank_base;
+     *
+     * And for waiting on a value, core code will use:
+     *   actual_target = target_msc - msc_base + vblank_base;
+     */
+    /*@{*/
+    int64_t vblank_base;
+    int64_t msc_base;
+    /*@}*/
+
+    /**
+     * Pointer to context to which this drawable is currently bound.
+     */
+    __DRIcontext *driContextPriv;
+
+    /**
+     * Pointer to screen on which this drawable was created.
+     */
+    __DRIscreen *driScreenPriv;
+
+    /**
+     * Controls swap interval as used by GLX_SGI_swap_control and
+     * GLX_MESA_swap_control.
+     */
+    unsigned int swap_interval;
+
+    struct {
+	unsigned int stamp;
+	drm_clip_rect_t clipRect;
+    } dri2;
+};
+
+/**
+ * Per-context private driver information.
+ */
+struct __DRIcontextRec {
+    /**
+     * Kernel context handle used to access the device lock.
+     */
+    drm_context_t hHWContext;
+
+    /**
+     * Device driver's private context data.  This structure is opaque.
+     */
+    void *driverPrivate;
+
+    /**
+     * Pointer to drawable currently bound to this context for drawing.
+     */
+    __DRIdrawable *driDrawablePriv;
+
+    /**
+     * Pointer to drawable currently bound to this context for reading.
+     */
+    __DRIdrawable *driReadablePriv;
+
+    /**
+     * Pointer to screen on which this context was created.
+     */
+    __DRIscreen *driScreenPriv;
+
+    /**
+     * The loaders's private context data.  This structure is opaque.
+     */
+    void *loaderPrivate;
+
+    struct {
+	int draw_stamp;
+	int read_stamp;
+    } dri2;
+};
+
+/**
+ * Per-screen private driver information.
+ */
+struct __DRIscreenRec {
+    /**
+     * Current screen's number
+     */
+    int myNum;
+
+    /**
+     * Callback functions into the hardware-specific DRI driver code.
+     */
+    struct __DriverAPIRec DriverAPI;
+
+    const __DRIextension **extensions;
+    /**
+     * DDX / 2D driver version information.
+     */
+    __DRIversion ddx_version;
+
+    /**
+     * DRI X extension version information.
+     */
+    __DRIversion dri_version;
+
+    /**
+     * DRM (kernel module) version information.
+     */
+    __DRIversion drm_version;
+
+    /**
+     * ID used when the client sets the drawable lock.
+     *
+     * The X server uses this value to detect if the client has died while
+     * holding the drawable lock.
+     */
+    int drawLockID;
+
+    /**
+     * File descriptor returned when the kernel device driver is opened.
+     * 
+     * Used to:
+     *   - authenticate client to kernel
+     *   - map the frame buffer, SAREA, etc.
+     *   - close the kernel device driver
+     */
+    int fd;
+
+    /**
+     * SAREA pointer 
+     *
+     * Used to access:
+     *   - the device lock
+     *   - the device-independent per-drawable and per-context(?) information
+     */
+    drm_sarea_t *pSAREA;
+
+    /**
+     * \name Direct frame buffer access information 
+     * Used for software fallbacks.
+     */
+    /*@{*/
+    unsigned char *pFB;
+    int fbSize;
+    int fbOrigin;
+    int fbStride;
+    int fbWidth;
+    int fbHeight;
+    int fbBPP;
+    /*@}*/
+
+    /**
+     * \name Device-dependent private information (stored in the SAREA).
+     *
+     * This data is accessed by the client driver only.
+     */
+    /*@{*/
+    void *pDevPriv;
+    int devPrivSize;
+    /*@}*/
+
+    /**
+     * Device-dependent private information (not stored in the SAREA).
+     * 
+     * This pointer is never touched by the DRI layer.
+     */
+#ifdef __cplusplus
+    void *priv;
+#else
+    void *private;
+#endif
+
+    /* Extensions provided by the loader. */
+    const __DRIgetDrawableInfoExtension *getDrawableInfo;
+    const __DRIsystemTimeExtension *systemTime;
+    const __DRIdamageExtension *damage;
+
+    struct {
+	/* Flag to indicate that this is a DRI2 screen.  Many of the above
+	 * fields will not be valid or initializaed in that case. */
+	int enabled;
+	__DRIdri2LoaderExtension *loader;
+	__DRIimageLookupExtension *image;
+	__DRIuseInvalidateExtension *useInvalidate;
+    } dri2;
+
+    /* The lock actually in use, old sarea or DRI2 */
+    drmLock *lock;
+
+    driOptionCache optionInfo;
+    driOptionCache optionCache;
+   unsigned int api_mask;
+   void *loaderPrivate;
+};
+
+extern void
+__driUtilUpdateDrawableInfo(__DRIdrawable *pdp);
+
+extern float
+driCalculateSwapUsage( __DRIdrawable *dPriv,
+		       int64_t last_swap_ust, int64_t current_ust );
+
+extern GLint
+driIntersectArea( drm_clip_rect_t rect1, drm_clip_rect_t rect2 );
+
+extern void
+dri2InvalidateDrawable(__DRIdrawable *drawable);
+
+#endif /* _DRI_UTIL_H_ */
diff --git a/mesalib/src/mesa/drivers/dri/common/spantmp2.h b/mesalib/src/mesa/drivers/dri/common/spantmp2.h
index a398b778e..83cfbb164 100644
--- a/mesalib/src/mesa/drivers/dri/common/spantmp2.h
+++ b/mesalib/src/mesa/drivers/dri/common/spantmp2.h
@@ -1,936 +1,936 @@
-/*

- * Copyright 2000-2001 VA Linux Systems, Inc.

- * (C) Copyright IBM Corporation 2004

- * All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * on the rights to use, copy, modify, merge, publish, distribute, sub

- * license, and/or sell copies of the Software, and to permit persons to whom

- * the Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

- * USE OR OTHER DEALINGS IN THE SOFTWARE.

- */

-

-/**

- * \file spantmp2.h

- *

- * Template file of span read / write functions.

- *

- * \author Keith Whitwell <keithw@tungstengraphics.com>

- * \author Gareth Hughes <gareth@nvidia.com>

- * \author Ian Romanick <idr@us.ibm.com>

- */

-

-#include "main/colormac.h"

-#include "spantmp_common.h"

-

-#ifndef DBG

-#define DBG 0

-#endif

-

-#ifndef HW_READ_CLIPLOOP

-#define HW_READ_CLIPLOOP()	HW_CLIPLOOP()

-#endif

-

-#ifndef HW_WRITE_CLIPLOOP

-#define HW_WRITE_CLIPLOOP()	HW_CLIPLOOP()

-#endif

-

-#if (SPANTMP_PIXEL_FMT == GL_RGB)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)

-

-/**

- ** GL_RGB, GL_UNSIGNED_SHORT_5_6_5

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-  p = PACK_COLOR_565( color[0], color[1], color[2] )

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, ((((int)r & 0xf8) << 8) |				\

-		      (((int)g & 0xfc) << 3) |				\

-		      (((int)b & 0xf8) >> 3)))				\

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      rgba[0] = ((p >> 8) & 0xf8) * 255 / 0xf8;				\

-      rgba[1] = ((p >> 3) & 0xfc) * 255 / 0xfc;				\

-      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\

-      rgba[3] = 0xff;							\

-   } while (0)

-

-#elif (SPANTMP_PIXEL_FMT == GL_RGB)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5_REV)

-

-/**

- ** GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-  p = PACK_COLOR_565_REV( color[0], color[1], color[2] )

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, PACK_COLOR_565_REV( r, g, b ))

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      p = p << 8 | p >> 8;						\

-      rgba[0] = ((p >> 8) & 0xf8) * 255 / 0xf8;				\

-      rgba[1] = ((p >> 3) & 0xfc) * 255 / 0xfc;				\

-      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\

-      rgba[3] = 0xff;							\

-   } while (0)

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_4_4_4_4)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-   p = PACK_COLOR_4444_REV(color[3], color[0], color[1], color[2])

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, PACK_COLOR_4444_REV(a, r, g, b))			\

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      rgba[0] = ((p >> 0) & 0xf) * 0x11;				\

-      rgba[1] = ((p >> 12) & 0xf) * 0x11;				\

-      rgba[2] = ((p >> 4) & 0xf) * 0x11;				\

-      rgba[3] = ((p >> 8) & 0xf) * 0x11;				\

-   } while (0)

-

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_4_4_4_4_REV)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-   p = PACK_COLOR_4444(color[3], color[0], color[1], color[2])

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, PACK_COLOR_4444(a, r, g, b))			\

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      rgba[0] = ((p >> 8) & 0xf) * 0x11;				\

-      rgba[1] = ((p >> 4) & 0xf) * 0x11;				\

-      rgba[2] = ((p >> 0) & 0xf) * 0x11;				\

-      rgba[3] = ((p >> 12) & 0xf) * 0x11;				\

-   } while (0)

-

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_1_5_5_5_REV)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-   p = PACK_COLOR_1555(color[3], color[0], color[1], color[2])

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, PACK_COLOR_1555(a, r, g, b))			\

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      rgba[0] = ((p >> 7) & 0xf8) * 255 / 0xf8;				\

-      rgba[1] = ((p >> 2) & 0xf8) * 255 / 0xf8;				\

-      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\

-      rgba[3] = ((p >> 15) & 0x1) * 0xff;				\

-   } while (0)

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_1_5_5_5)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-#define INIT_MONO_PIXEL(p, color) \

-   p = PACK_COLOR_1555_REV(color[3], color[0], color[1], color[2])

-

-#define WRITE_RGBA( _x, _y, r, g, b, a )				\

-   PUT_VALUE(_x, _y, PACK_COLOR_1555_REV(a, r, g, b))			\

-

-#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )					\

-   do {									\

-      GLushort p = GET_VALUE(_x, _y);					\

-      p = p << 8 | p >> 8;						\

-      rgba[0] = ((p >> 7) & 0xf8) * 255 / 0xf8;				\

-      rgba[1] = ((p >> 2) & 0xf8) * 255 / 0xf8;				\

-      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\

-      rgba[3] = ((p >> 15) & 0x1) * 0xff;				\

-   } while (0)

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-# define INIT_MONO_PIXEL(p, color)                       \

-     p = PACK_COLOR_8888(color[3], color[0], color[1], color[2]) 

-

-# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \

-   PUT_VALUE(_x, _y, ((r << 16) |					\

-		      (g << 8) |					\

-		      (b << 0) |					\

-		      (a << 24)))

-

-#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)

-

-# if defined( USE_X86_ASM )

-#  define READ_RGBA(rgba, _x, _y)                                       \

-    do {                                                                \

-       GLuint p = GET_VALUE(_x, _y);					\

-       __asm__ __volatile__( "bswap	%0; rorl $8, %0"                \

-				: "=r" (p) : "0" (p) );                 \

-       ((GLuint *)rgba)[0] = p;                                         \

-    } while (0)

-# elif defined( MESA_BIG_ENDIAN )

-    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single

-     * rotlwi instruction.  It also produces good code on SPARC.

-     */

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = GET_VALUE(_x, _y);					\

-        GLuint t = p;                                                   \

-        *((uint32_t *) rgba) = (t >> 24) | (p << 8);                    \

-     } while (0)

-# else

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = GET_VALUE(_x, _y);					\

-	rgba[0] = (p >> 16) & 0xff;					\

-	rgba[1] = (p >>  8) & 0xff;					\

-	rgba[2] = (p >>  0) & 0xff;					\

-	rgba[3] = (p >> 24) & 0xff;					\

-     } while (0)

-# endif

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGRA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8)

-

-/**

- ** GL_BGRA, GL_UNSIGNED_INT_8_8_8_8

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-# define INIT_MONO_PIXEL(p, color)                       \

-     p = PACK_COLOR_8888(color[2], color[1], color[0], color[3]) 

-

-# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \

-   PUT_VALUE(_x, _y, ((r << 8) |					\

-		      (g << 16) |					\

-		      (b << 24) |					\

-		      (a << 0)))

-

-#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)

-

-# if defined( USE_X86_ASM )

-#  define READ_RGBA(rgba, _x, _y)                                       \

-    do {                                                                \

-       GLuint p = GET_VALUE(_x, _y);					\

-       __asm__ __volatile__( "rorl $8, %0"				\

-				: "=r" (p) : "0" (p) );                 \

-       ((GLuint *)rgba)[0] = p;                                         \

-    } while (0)

-# elif defined( MESA_BIG_ENDIAN )

-    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single

-     * rotlwi instruction.  It also produces good code on SPARC.

-     */

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = CPU_TO_LE32(GET_VALUE(_x, _y));                      \

-        GLuint t = p;                                                   \

-        *((uint32_t *) rgba) = (t >> 24) | (p << 8);                    \

-     } while (0)

-# else

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = GET_VALUE(_x, _y);					\

-	rgba[0] = (p >>  8) & 0xff;					\

-	rgba[1] = (p >> 16) & 0xff;					\

-	rgba[2] = (p >> 24) & 0xff;					\

-	rgba[3] = (p >>  0) & 0xff;					\

-     } while (0)

-# endif

-

-#elif (SPANTMP_PIXEL_FMT == GL_BGR) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-

-/**

- ** GL_BGR, GL_UNSIGNED_INT_8_8_8_8_REV

- **

- ** This is really for MESA_FORMAT_XRGB8888.  The spantmp code needs to be

- ** kicked to the curb, and we need to just code-gen this.

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-# define INIT_MONO_PIXEL(p, color)                       \

-     p = PACK_COLOR_8888(0xff, color[0], color[1], color[2])

-

-# define WRITE_RGBA(_x, _y, r, g, b, a)					\

-   PUT_VALUE(_x, _y, ((r << 16) |					\

-		      (g << 8) |					\

-		      (b << 0) |					\

-		      (0xff << 24)))

-

-#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)

-

-# if defined( USE_X86_ASM )

-#  define READ_RGBA(rgba, _x, _y)                                       \

-    do {                                                                \

-       GLuint p = GET_VALUE(_x, _y);					\

-       __asm__ __volatile__( "bswap	%0; rorl $8, %0"                \

-				: "=r" (p) : "0" (p) );                 \

-       ((GLuint *)rgba)[0] = p | 0xff000000;				\

-    } while (0)

-# elif defined( MESA_BIG_ENDIAN )

-    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single

-     * rotlwi instruction.  It also produces good code on SPARC.

-     */

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = GET_VALUE(_x, _y);					\

-        *((uint32_t *) rgba) = (p << 8) | 0xff;				\

-     } while (0)

-# else

-#  define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLuint p = GET_VALUE(_x, _y);					\

-	rgba[0] = (p >> 16) & 0xff;					\

-	rgba[1] = (p >>  8) & 0xff;					\

-	rgba[2] = (p >>  0) & 0xff;					\

-	rgba[3] = 0xff;							\

-     } while (0)

-# endif

-

-#elif (SPANTMP_PIXEL_FMT == GL_ALPHA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_BYTE)

-

-/**

- ** GL_ALPHA, GL_UNSIGNED_BYTE

- **/

-

-#ifndef GET_VALUE

-#ifndef GET_PTR

-#define GET_PTR(_x, _y) (     buf + (_x) + (_y) * pitch)

-#endif

-

-#define GET_VALUE(_x, _y) *(volatile GLubyte *)(GET_PTR(_x, _y))

-#define PUT_VALUE(_x, _y, _v) *(volatile GLubyte *)(GET_PTR(_x, _y)) = (_v)

-#endif /* GET_VALUE */

-

-# define INIT_MONO_PIXEL(p, color)                       \

-     p = color[3]

-

-# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \

-   PUT_VALUE(_x, _y, a | (r & 0 /* quiet warnings */))

-

-#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)

-

-#define READ_RGBA( rgba, _x, _y )				        \

-     do {								\

-        GLubyte p = GET_VALUE(_x, _y);					\

-	rgba[0] = 0;							\

-	rgba[1] = 0;							\

-	rgba[2] = 0;							\

-	rgba[3] = p;							\

-     } while (0)

-

-#else

-#error SPANTMP_PIXEL_FMT must be set to a valid value!

-#endif

-

-

-

-/**

- ** Assembly routines.

- **/

-

-#if defined( USE_MMX_ASM ) || defined( USE_SSE_ASM )

-#include "x86/read_rgba_span_x86.h"

-#include "x86/common_x86_asm.h"

-#endif

-

-static void TAG(WriteRGBASpan)( struct gl_context *ctx,

-                                struct gl_renderbuffer *rb,

-				GLuint n, GLint x, GLint y,

-				const void *values, const GLubyte mask[] )

-{

-   (void) ctx;

-

-   HW_WRITE_LOCK()

-      {

-         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;

-	 GLint x1;

-	 GLint n1;

-	 LOCAL_VARS;

-

-	 y = Y_FLIP(y);

-

-	 HW_WRITE_CLIPLOOP()

-	    {

-	       GLint i = 0;

-	       CLIPSPAN(x,y,n,x1,n1,i);

-

-	       if (DBG) fprintf(stderr, "WriteRGBASpan %d..%d (x1 %d)\n",

-				(int)i, (int)n1, (int)x1);

-

-	       if (mask)

-	       {

-		  for (;n1>0;i++,x1++,n1--)

-		     if (mask[i])

-			WRITE_RGBA( x1, y,

-				    rgba[i][0], rgba[i][1],

-				    rgba[i][2], rgba[i][3] );

-	       }

-	       else

-	       {

-		  for (;n1>0;i++,x1++,n1--)

-		     WRITE_RGBA( x1, y,

-				 rgba[i][0], rgba[i][1],

-				 rgba[i][2], rgba[i][3] );

-	       }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_WRITE_UNLOCK();

-}

-

-static void TAG(WriteRGBSpan)( struct gl_context *ctx,

-                               struct gl_renderbuffer *rb,

-			       GLuint n, GLint x, GLint y,

-			       const void *values, const GLubyte mask[] )

-{

-   (void) ctx;

-

-   HW_WRITE_LOCK()

-      {

-         const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;

-	 GLint x1;

-	 GLint n1;

-	 LOCAL_VARS;

-

-	 y = Y_FLIP(y);

-

-	 HW_WRITE_CLIPLOOP()

-	    {

-	       GLint i = 0;

-	       CLIPSPAN(x,y,n,x1,n1,i);

-

-	       if (DBG) fprintf(stderr, "WriteRGBSpan %d..%d (x1 %d)\n",

-				(int)i, (int)n1, (int)x1);

-

-	       if (mask)

-	       {

-		  for (;n1>0;i++,x1++,n1--)

-		     if (mask[i])

-			WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 255 );

-	       }

-	       else

-	       {

-		  for (;n1>0;i++,x1++,n1--)

-		     WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 255 );

-	       }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_WRITE_UNLOCK();

-}

-

-static void TAG(WriteRGBAPixels)( struct gl_context *ctx,

-                                  struct gl_renderbuffer *rb,

-                                  GLuint n, const GLint x[], const GLint y[],

-                                  const void *values, const GLubyte mask[] )

-{

-   (void) ctx;

-

-   HW_WRITE_LOCK()

-      {

-         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;

-	 GLint i;

-	 LOCAL_VARS;

-

-	 if (DBG) fprintf(stderr, "WriteRGBAPixels\n");

-

-	 HW_WRITE_CLIPLOOP()

-	    {

-	       if (mask)

-	       {

-	          for (i=0;i<n;i++)

-	          {

-		     if (mask[i]) {

-		        const int fy = Y_FLIP(y[i]);

-		        if (CLIPPIXEL(x[i],fy))

-			   WRITE_RGBA( x[i], fy,

-				       rgba[i][0], rgba[i][1],

-				       rgba[i][2], rgba[i][3] );

-		     }

-	          }

-	       }

-	       else

-	       {

-	          for (i=0;i<n;i++)

-	          {

-		     const int fy = Y_FLIP(y[i]);

-		     if (CLIPPIXEL(x[i],fy))

-			WRITE_RGBA( x[i], fy,

-				    rgba[i][0], rgba[i][1],

-				    rgba[i][2], rgba[i][3] );

-	          }

-	       }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_WRITE_UNLOCK();

-}

-

-

-static void TAG(WriteMonoRGBASpan)( struct gl_context *ctx,	

-                                    struct gl_renderbuffer *rb,

-				    GLuint n, GLint x, GLint y, 

-				    const void *value, const GLubyte mask[] )

-{

-   (void) ctx;

-

-   HW_WRITE_LOCK()

-      {

-         const GLubyte *color = (const GLubyte *) value;

-	 GLint x1;

-	 GLint n1;

-	 LOCAL_VARS;

-	 INIT_MONO_PIXEL(p, color);

-

-	 y = Y_FLIP( y );

-

-	 if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n");

-

-	 HW_WRITE_CLIPLOOP()

-	    {

-	       GLint i = 0;

-	       CLIPSPAN(x,y,n,x1,n1,i);

-	       if (mask)

-	       {

-	          for (;n1>0;i++,x1++,n1--)

-		     if (mask[i])

-		        WRITE_PIXEL( x1, y, p );

-	       }

-	       else

-	       {

-	          for (;n1>0;i++,x1++,n1--)

-		     WRITE_PIXEL( x1, y, p );

-	       }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_WRITE_UNLOCK();

-}

-

-

-static void TAG(WriteMonoRGBAPixels)( struct gl_context *ctx,

-                                      struct gl_renderbuffer *rb,

-				      GLuint n,

-				      const GLint x[], const GLint y[],

-				      const void *value,

-				      const GLubyte mask[] ) 

-{

-   (void) ctx;

-

-   HW_WRITE_LOCK()

-      {

-         const GLubyte *color = (const GLubyte *) value;

-	 GLint i;

-	 LOCAL_VARS;

-	 INIT_MONO_PIXEL(p, color);

-

-	 if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n");

-

-	 HW_WRITE_CLIPLOOP()

-	    {

-	       if (mask)

-	       {

-		  for (i=0;i<n;i++)

-		     if (mask[i]) {

-			int fy = Y_FLIP(y[i]);

-			if (CLIPPIXEL( x[i], fy ))

-			   WRITE_PIXEL( x[i], fy, p );

-		     }

-	       }

-	       else

-	       {

-		  for (i=0;i<n;i++) {

-		     int fy = Y_FLIP(y[i]);

-		     if (CLIPPIXEL( x[i], fy ))

-			WRITE_PIXEL( x[i], fy, p );

-		  }

-	       }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_WRITE_UNLOCK();

-}

-

-

-static void TAG(ReadRGBASpan)( struct gl_context *ctx,

-                               struct gl_renderbuffer *rb,

-			       GLuint n, GLint x, GLint y, void *values)

-{

-   (void) ctx;

-

-   HW_READ_LOCK()

-      {

-         GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;

-	 GLint x1,n1;

-	 LOCAL_VARS;

-

-	 y = Y_FLIP(y);

-

-	 if (DBG) fprintf(stderr, "ReadRGBASpan\n");

-

-	 HW_READ_CLIPLOOP()

-	    {

-	       GLint i = 0;

-	       CLIPSPAN(x,y,n,x1,n1,i);

-	       for (;n1>0;i++,x1++,n1--)

-		  READ_RGBA( rgba[i], x1, y );

-	    }

-         HW_ENDCLIPLOOP();

-      }

-   HW_READ_UNLOCK();

-}

-

-

-#if defined(GET_PTR) && \

-   defined(USE_MMX_ASM) && \

-   (((SPANTMP_PIXEL_FMT == GL_BGRA) && \

-	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)) || \

-    ((SPANTMP_PIXEL_FMT == GL_RGB) && \

-	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)))

-static void TAG2(ReadRGBASpan,_MMX)( struct gl_context *ctx,

-                                     struct gl_renderbuffer *rb,

-                                     GLuint n, GLint x, GLint y, void *values)

-{

-#ifndef USE_INNER_EMMS

-   /* The EMMS instruction is directly in-lined here because using GCC's

-    * built-in _mm_empty function was found to utterly destroy performance.

-    */

-   __asm__ __volatile__( "emms" );

-#endif

-

-   (void) ctx;

-

-   HW_READ_LOCK()

-     {

-        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;

-	GLint x1,n1;

-	LOCAL_VARS;

-

-	y = Y_FLIP(y);

-

-	if (DBG) fprintf(stderr, "ReadRGBASpan\n");

-

-	HW_READ_CLIPLOOP()

-	  {

-	     GLint i = 0;

-	     CLIPSPAN(x,y,n,x1,n1,i);

-

-	       {

-		  const void * src = GET_PTR( x1, y );

-#if (SPANTMP_PIXEL_FMT == GL_RGB) && \

-		  (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)

-		  _generic_read_RGBA_span_RGB565_MMX( src, rgba[i], n1 );

-#else

-		  _generic_read_RGBA_span_BGRA8888_REV_MMX( src, rgba[i], n1 );

-#endif

-	       }

-	  }

-	HW_ENDCLIPLOOP();

-     }

-   HW_READ_UNLOCK();

-#ifndef USE_INNER_EMMS

-   __asm__ __volatile__( "emms" );

-#endif

-}

-#endif

-

-

-#if defined(GET_PTR) &&	\

-   defined(USE_SSE_ASM) && \

-   (SPANTMP_PIXEL_FMT == GL_BGRA) && \

-     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-static void TAG2(ReadRGBASpan,_SSE2)( struct gl_context *ctx,

-                                      struct gl_renderbuffer *rb,

-                                      GLuint n, GLint x, GLint y,

-                                      void *values)

-{

-   (void) ctx;

-

-   HW_READ_LOCK()

-     {

-        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;

-	GLint x1,n1;

-	LOCAL_VARS;

-

-	y = Y_FLIP(y);

-

-	if (DBG) fprintf(stderr, "ReadRGBASpan\n");

-

-	HW_READ_CLIPLOOP()

-	  {

-	     GLint i = 0;

-	     CLIPSPAN(x,y,n,x1,n1,i);

-

-	       {

-		  const void * src = GET_PTR( x1, y );

-		  _generic_read_RGBA_span_BGRA8888_REV_SSE2( src, rgba[i], n1 );

-	       }

-	  }

-	HW_ENDCLIPLOOP();

-     }

-   HW_READ_UNLOCK();

-}

-#endif

-

-#if defined(GET_PTR) &&	\

-   defined(USE_SSE_ASM) && \

-   (SPANTMP_PIXEL_FMT == GL_BGRA) && \

-     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-static void TAG2(ReadRGBASpan,_SSE)( struct gl_context *ctx,

-                                     struct gl_renderbuffer *rb,

-                                     GLuint n, GLint x, GLint y,

-                                     void *values)

-{

-#ifndef USE_INNER_EMMS

-   /* The EMMS instruction is directly in-lined here because using GCC's

-    * built-in _mm_empty function was found to utterly destroy performance.

-    */

-   __asm__ __volatile__( "emms" );

-#endif

-

-   (void) ctx;

-

-   HW_READ_LOCK()

-     {

-        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;

-	GLint x1,n1;

-	LOCAL_VARS;

-

-	y = Y_FLIP(y);

-

-	if (DBG) fprintf(stderr, "ReadRGBASpan\n");

-

-	HW_READ_CLIPLOOP()

-	  {

-	     GLint i = 0;

-	     CLIPSPAN(x,y,n,x1,n1,i);

-

-	       {

-		  const void * src = GET_PTR( x1, y );

-		  _generic_read_RGBA_span_BGRA8888_REV_SSE( src, rgba[i], n1 );

-	       }

-	  }

-	HW_ENDCLIPLOOP();

-     }

-   HW_READ_UNLOCK();

-#ifndef USE_INNER_EMMS

-   __asm__ __volatile__( "emms" );

-#endif

-}

-#endif

-

-

-static void TAG(ReadRGBAPixels)( struct gl_context *ctx,

-                                 struct gl_renderbuffer *rb,

-				 GLuint n, const GLint x[], const GLint y[],

-				 void *values )

-{

-   (void) ctx;

-

-   HW_READ_LOCK()

-      {

-         GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;

-	 GLint i;

-	 LOCAL_VARS;

-

-	 if (DBG) fprintf(stderr, "ReadRGBAPixels\n");

-

-	 HW_READ_CLIPLOOP()

-	    {

-               for (i=0;i<n;i++) {

-                  int fy = Y_FLIP( y[i] );

-                     if (CLIPPIXEL( x[i], fy ))

-                        READ_RGBA( rgba[i], x[i], fy );

-               }

-	    }

-	 HW_ENDCLIPLOOP();

-      }

-   HW_READ_UNLOCK();

-}

-

-static void TAG(InitPointers)(struct gl_renderbuffer *rb)

-{

-   rb->PutRow = TAG(WriteRGBASpan);

-   rb->PutRowRGB = TAG(WriteRGBSpan);

-   rb->PutMonoRow = TAG(WriteMonoRGBASpan);

-   rb->PutValues = TAG(WriteRGBAPixels);

-   rb->PutMonoValues = TAG(WriteMonoRGBAPixels);

-   rb->GetValues = TAG(ReadRGBAPixels);

-

-#if defined(GET_PTR)

-#if defined(USE_SSE_ASM) && \

-   (SPANTMP_PIXEL_FMT == GL_BGRA) && \

-     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-   if ( cpu_has_xmm2 ) {

-      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "SSE2" );

-      rb->GetRow = TAG2(ReadRGBASpan, _SSE2);

-   }

-   else

-#endif

-#if defined(USE_SSE_ASM) && \

-   (SPANTMP_PIXEL_FMT == GL_BGRA) && \

-     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)

-   if ( cpu_has_xmm ) {

-      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "SSE" );

-      rb->GetRow = TAG2(ReadRGBASpan, _SSE);

-   }

-   else

-#endif

-#if defined(USE_MMX_ASM) && \

-   (((SPANTMP_PIXEL_FMT == GL_BGRA) && \

-	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)) || \

-    ((SPANTMP_PIXEL_FMT == GL_RGB) && \

-	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)))

-   if ( cpu_has_mmx ) {

-      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "MMX" );

-      rb->GetRow = TAG2(ReadRGBASpan, _MMX);

-   }

-   else

-#endif

-#endif /* GET_PTR */

-   {

-      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "C" );

-      rb->GetRow = TAG(ReadRGBASpan);

-   }

-

-}

-

-

-#undef INIT_MONO_PIXEL

-#undef WRITE_PIXEL

-#undef WRITE_RGBA

-#undef READ_RGBA

-#undef TAG

-#undef TAG2

-#undef GET_VALUE

-#undef PUT_VALUE

-#undef GET_PTR

-#undef SPANTMP_PIXEL_FMT

-#undef SPANTMP_PIXEL_TYPE

+/*
+ * Copyright 2000-2001 VA Linux Systems, Inc.
+ * (C) Copyright IBM Corporation 2004
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * \file spantmp2.h
+ *
+ * Template file of span read / write functions.
+ *
+ * \author Keith Whitwell <keithw@tungstengraphics.com>
+ * \author Gareth Hughes <gareth@nvidia.com>
+ * \author Ian Romanick <idr@us.ibm.com>
+ */
+
+#include "main/colormac.h"
+#include "spantmp_common.h"
+
+#ifndef DBG
+#define DBG 0
+#endif
+
+#ifndef HW_READ_CLIPLOOP
+#define HW_READ_CLIPLOOP()	HW_CLIPLOOP()
+#endif
+
+#ifndef HW_WRITE_CLIPLOOP
+#define HW_WRITE_CLIPLOOP()	HW_CLIPLOOP()
+#endif
+
+#if (SPANTMP_PIXEL_FMT == GL_RGB)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)
+
+/**
+ ** GL_RGB, GL_UNSIGNED_SHORT_5_6_5
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+  p = PACK_COLOR_565( color[0], color[1], color[2] )
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, ((((int)r & 0xf8) << 8) |				\
+		      (((int)g & 0xfc) << 3) |				\
+		      (((int)b & 0xf8) >> 3)))				\
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      rgba[0] = ((p >> 8) & 0xf8) * 255 / 0xf8;				\
+      rgba[1] = ((p >> 3) & 0xfc) * 255 / 0xfc;				\
+      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\
+      rgba[3] = 0xff;							\
+   } while (0)
+
+#elif (SPANTMP_PIXEL_FMT == GL_RGB)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5_REV)
+
+/**
+ ** GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+  p = PACK_COLOR_565_REV( color[0], color[1], color[2] )
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, PACK_COLOR_565_REV( r, g, b ))
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      p = p << 8 | p >> 8;						\
+      rgba[0] = ((p >> 8) & 0xf8) * 255 / 0xf8;				\
+      rgba[1] = ((p >> 3) & 0xfc) * 255 / 0xfc;				\
+      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\
+      rgba[3] = 0xff;							\
+   } while (0)
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_4_4_4_4)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+   p = PACK_COLOR_4444_REV(color[3], color[0], color[1], color[2])
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, PACK_COLOR_4444_REV(a, r, g, b))			\
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      rgba[0] = ((p >> 0) & 0xf) * 0x11;				\
+      rgba[1] = ((p >> 12) & 0xf) * 0x11;				\
+      rgba[2] = ((p >> 4) & 0xf) * 0x11;				\
+      rgba[3] = ((p >> 8) & 0xf) * 0x11;				\
+   } while (0)
+
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_4_4_4_4_REV)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_SHORT_4_4_4_4_REV
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+   p = PACK_COLOR_4444(color[3], color[0], color[1], color[2])
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, PACK_COLOR_4444(a, r, g, b))			\
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      rgba[0] = ((p >> 8) & 0xf) * 0x11;				\
+      rgba[1] = ((p >> 4) & 0xf) * 0x11;				\
+      rgba[2] = ((p >> 0) & 0xf) * 0x11;				\
+      rgba[3] = ((p >> 12) & 0xf) * 0x11;				\
+   } while (0)
+
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_1_5_5_5_REV)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+   p = PACK_COLOR_1555(color[3], color[0], color[1], color[2])
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, PACK_COLOR_1555(a, r, g, b))			\
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      rgba[0] = ((p >> 7) & 0xf8) * 255 / 0xf8;				\
+      rgba[1] = ((p >> 2) & 0xf8) * 255 / 0xf8;				\
+      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\
+      rgba[3] = ((p >> 15) & 0x1) * 0xff;				\
+   } while (0)
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA)  && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_1_5_5_5)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (buf + (_x) * 2 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLushort *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLushort *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+#define INIT_MONO_PIXEL(p, color) \
+   p = PACK_COLOR_1555_REV(color[3], color[0], color[1], color[2])
+
+#define WRITE_RGBA( _x, _y, r, g, b, a )				\
+   PUT_VALUE(_x, _y, PACK_COLOR_1555_REV(a, r, g, b))			\
+
+#define WRITE_PIXEL( _x, _y, p ) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )					\
+   do {									\
+      GLushort p = GET_VALUE(_x, _y);					\
+      p = p << 8 | p >> 8;						\
+      rgba[0] = ((p >> 7) & 0xf8) * 255 / 0xf8;				\
+      rgba[1] = ((p >> 2) & 0xf8) * 255 / 0xf8;				\
+      rgba[2] = ((p << 3) & 0xf8) * 255 / 0xf8;				\
+      rgba[3] = ((p >> 15) & 0x1) * 0xff;				\
+   } while (0)
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+# define INIT_MONO_PIXEL(p, color)                       \
+     p = PACK_COLOR_8888(color[3], color[0], color[1], color[2]) 
+
+# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \
+   PUT_VALUE(_x, _y, ((r << 16) |					\
+		      (g << 8) |					\
+		      (b << 0) |					\
+		      (a << 24)))
+
+#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)
+
+# if defined( USE_X86_ASM )
+#  define READ_RGBA(rgba, _x, _y)                                       \
+    do {                                                                \
+       GLuint p = GET_VALUE(_x, _y);					\
+       __asm__ __volatile__( "bswap	%0; rorl $8, %0"                \
+				: "=r" (p) : "0" (p) );                 \
+       ((GLuint *)rgba)[0] = p;                                         \
+    } while (0)
+# elif defined( MESA_BIG_ENDIAN )
+    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single
+     * rotlwi instruction.  It also produces good code on SPARC.
+     */
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = GET_VALUE(_x, _y);					\
+        GLuint t = p;                                                   \
+        *((uint32_t *) rgba) = (t >> 24) | (p << 8);                    \
+     } while (0)
+# else
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = GET_VALUE(_x, _y);					\
+	rgba[0] = (p >> 16) & 0xff;					\
+	rgba[1] = (p >>  8) & 0xff;					\
+	rgba[2] = (p >>  0) & 0xff;					\
+	rgba[3] = (p >> 24) & 0xff;					\
+     } while (0)
+# endif
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGRA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8)
+
+/**
+ ** GL_BGRA, GL_UNSIGNED_INT_8_8_8_8
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+# define INIT_MONO_PIXEL(p, color)                       \
+     p = PACK_COLOR_8888(color[2], color[1], color[0], color[3]) 
+
+# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \
+   PUT_VALUE(_x, _y, ((r << 8) |					\
+		      (g << 16) |					\
+		      (b << 24) |					\
+		      (a << 0)))
+
+#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)
+
+# if defined( USE_X86_ASM )
+#  define READ_RGBA(rgba, _x, _y)                                       \
+    do {                                                                \
+       GLuint p = GET_VALUE(_x, _y);					\
+       __asm__ __volatile__( "rorl $8, %0"				\
+				: "=r" (p) : "0" (p) );                 \
+       ((GLuint *)rgba)[0] = p;                                         \
+    } while (0)
+# elif defined( MESA_BIG_ENDIAN )
+    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single
+     * rotlwi instruction.  It also produces good code on SPARC.
+     */
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = CPU_TO_LE32(GET_VALUE(_x, _y));                      \
+        GLuint t = p;                                                   \
+        *((uint32_t *) rgba) = (t >> 24) | (p << 8);                    \
+     } while (0)
+# else
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = GET_VALUE(_x, _y);					\
+	rgba[0] = (p >>  8) & 0xff;					\
+	rgba[1] = (p >> 16) & 0xff;					\
+	rgba[2] = (p >> 24) & 0xff;					\
+	rgba[3] = (p >>  0) & 0xff;					\
+     } while (0)
+# endif
+
+#elif (SPANTMP_PIXEL_FMT == GL_BGR) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+
+/**
+ ** GL_BGR, GL_UNSIGNED_INT_8_8_8_8_REV
+ **
+ ** This is really for MESA_FORMAT_XRGB8888.  The spantmp code needs to be
+ ** kicked to the curb, and we need to just code-gen this.
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (     buf + (_x) * 4 + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLuint *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLuint *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+# define INIT_MONO_PIXEL(p, color)                       \
+     p = PACK_COLOR_8888(0xff, color[0], color[1], color[2])
+
+# define WRITE_RGBA(_x, _y, r, g, b, a)					\
+   PUT_VALUE(_x, _y, ((r << 16) |					\
+		      (g << 8) |					\
+		      (b << 0) |					\
+		      (0xff << 24)))
+
+#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)
+
+# if defined( USE_X86_ASM )
+#  define READ_RGBA(rgba, _x, _y)                                       \
+    do {                                                                \
+       GLuint p = GET_VALUE(_x, _y);					\
+       __asm__ __volatile__( "bswap	%0; rorl $8, %0"                \
+				: "=r" (p) : "0" (p) );                 \
+       ((GLuint *)rgba)[0] = p | 0xff000000;				\
+    } while (0)
+# elif defined( MESA_BIG_ENDIAN )
+    /* On PowerPC with GCC 3.4.2 the shift madness below becomes a single
+     * rotlwi instruction.  It also produces good code on SPARC.
+     */
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = GET_VALUE(_x, _y);					\
+        *((uint32_t *) rgba) = (p << 8) | 0xff;				\
+     } while (0)
+# else
+#  define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLuint p = GET_VALUE(_x, _y);					\
+	rgba[0] = (p >> 16) & 0xff;					\
+	rgba[1] = (p >>  8) & 0xff;					\
+	rgba[2] = (p >>  0) & 0xff;					\
+	rgba[3] = 0xff;							\
+     } while (0)
+# endif
+
+#elif (SPANTMP_PIXEL_FMT == GL_ALPHA) && (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_BYTE)
+
+/**
+ ** GL_ALPHA, GL_UNSIGNED_BYTE
+ **/
+
+#ifndef GET_VALUE
+#ifndef GET_PTR
+#define GET_PTR(_x, _y) (     buf + (_x) + (_y) * pitch)
+#endif
+
+#define GET_VALUE(_x, _y) *(volatile GLubyte *)(GET_PTR(_x, _y))
+#define PUT_VALUE(_x, _y, _v) *(volatile GLubyte *)(GET_PTR(_x, _y)) = (_v)
+#endif /* GET_VALUE */
+
+# define INIT_MONO_PIXEL(p, color)                       \
+     p = color[3]
+
+# define WRITE_RGBA(_x, _y, r, g, b, a)                                 \
+   PUT_VALUE(_x, _y, a | (r & 0 /* quiet warnings */))
+
+#define WRITE_PIXEL(_x, _y, p) PUT_VALUE(_x, _y, p)
+
+#define READ_RGBA( rgba, _x, _y )				        \
+     do {								\
+        GLubyte p = GET_VALUE(_x, _y);					\
+	rgba[0] = 0;							\
+	rgba[1] = 0;							\
+	rgba[2] = 0;							\
+	rgba[3] = p;							\
+     } while (0)
+
+#else
+#error SPANTMP_PIXEL_FMT must be set to a valid value!
+#endif
+
+
+
+/**
+ ** Assembly routines.
+ **/
+
+#if defined( USE_MMX_ASM ) || defined( USE_SSE_ASM )
+#include "x86/read_rgba_span_x86.h"
+#include "x86/common_x86_asm.h"
+#endif
+
+static void TAG(WriteRGBASpan)( struct gl_context *ctx,
+                                struct gl_renderbuffer *rb,
+				GLuint n, GLint x, GLint y,
+				const void *values, const GLubyte mask[] )
+{
+   (void) ctx;
+
+   HW_WRITE_LOCK()
+      {
+         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+
+	 y = Y_FLIP(y);
+
+	 HW_WRITE_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+
+	       if (DBG) fprintf(stderr, "WriteRGBASpan %d..%d (x1 %d)\n",
+				(int)i, (int)n1, (int)x1);
+
+	       if (mask)
+	       {
+		  for (;n1>0;i++,x1++,n1--)
+		     if (mask[i])
+			WRITE_RGBA( x1, y,
+				    rgba[i][0], rgba[i][1],
+				    rgba[i][2], rgba[i][3] );
+	       }
+	       else
+	       {
+		  for (;n1>0;i++,x1++,n1--)
+		     WRITE_RGBA( x1, y,
+				 rgba[i][0], rgba[i][1],
+				 rgba[i][2], rgba[i][3] );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+
+static void TAG(WriteRGBSpan)( struct gl_context *ctx,
+                               struct gl_renderbuffer *rb,
+			       GLuint n, GLint x, GLint y,
+			       const void *values, const GLubyte mask[] )
+{
+   (void) ctx;
+
+   HW_WRITE_LOCK()
+      {
+         const GLubyte (*rgb)[3] = (const GLubyte (*)[3]) values;
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+
+	 y = Y_FLIP(y);
+
+	 HW_WRITE_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+
+	       if (DBG) fprintf(stderr, "WriteRGBSpan %d..%d (x1 %d)\n",
+				(int)i, (int)n1, (int)x1);
+
+	       if (mask)
+	       {
+		  for (;n1>0;i++,x1++,n1--)
+		     if (mask[i])
+			WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 255 );
+	       }
+	       else
+	       {
+		  for (;n1>0;i++,x1++,n1--)
+		     WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 255 );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+
+static void TAG(WriteRGBAPixels)( struct gl_context *ctx,
+                                  struct gl_renderbuffer *rb,
+                                  GLuint n, const GLint x[], const GLint y[],
+                                  const void *values, const GLubyte mask[] )
+{
+   (void) ctx;
+
+   HW_WRITE_LOCK()
+      {
+         const GLubyte (*rgba)[4] = (const GLubyte (*)[4]) values;
+	 GLint i;
+	 LOCAL_VARS;
+
+	 if (DBG) fprintf(stderr, "WriteRGBAPixels\n");
+
+	 HW_WRITE_CLIPLOOP()
+	    {
+	       if (mask)
+	       {
+	          for (i=0;i<n;i++)
+	          {
+		     if (mask[i]) {
+		        const int fy = Y_FLIP(y[i]);
+		        if (CLIPPIXEL(x[i],fy))
+			   WRITE_RGBA( x[i], fy,
+				       rgba[i][0], rgba[i][1],
+				       rgba[i][2], rgba[i][3] );
+		     }
+	          }
+	       }
+	       else
+	       {
+	          for (i=0;i<n;i++)
+	          {
+		     const int fy = Y_FLIP(y[i]);
+		     if (CLIPPIXEL(x[i],fy))
+			WRITE_RGBA( x[i], fy,
+				    rgba[i][0], rgba[i][1],
+				    rgba[i][2], rgba[i][3] );
+	          }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+
+
+static void TAG(WriteMonoRGBASpan)( struct gl_context *ctx,	
+                                    struct gl_renderbuffer *rb,
+				    GLuint n, GLint x, GLint y, 
+				    const void *value, const GLubyte mask[] )
+{
+   (void) ctx;
+
+   HW_WRITE_LOCK()
+      {
+         const GLubyte *color = (const GLubyte *) value;
+	 GLint x1;
+	 GLint n1;
+	 LOCAL_VARS;
+	 INIT_MONO_PIXEL(p, color);
+
+	 y = Y_FLIP( y );
+
+	 if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n");
+
+	 HW_WRITE_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+	       if (mask)
+	       {
+	          for (;n1>0;i++,x1++,n1--)
+		     if (mask[i])
+		        WRITE_PIXEL( x1, y, p );
+	       }
+	       else
+	       {
+	          for (;n1>0;i++,x1++,n1--)
+		     WRITE_PIXEL( x1, y, p );
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+
+
+static void TAG(WriteMonoRGBAPixels)( struct gl_context *ctx,
+                                      struct gl_renderbuffer *rb,
+				      GLuint n,
+				      const GLint x[], const GLint y[],
+				      const void *value,
+				      const GLubyte mask[] ) 
+{
+   (void) ctx;
+
+   HW_WRITE_LOCK()
+      {
+         const GLubyte *color = (const GLubyte *) value;
+	 GLint i;
+	 LOCAL_VARS;
+	 INIT_MONO_PIXEL(p, color);
+
+	 if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n");
+
+	 HW_WRITE_CLIPLOOP()
+	    {
+	       if (mask)
+	       {
+		  for (i=0;i<n;i++)
+		     if (mask[i]) {
+			int fy = Y_FLIP(y[i]);
+			if (CLIPPIXEL( x[i], fy ))
+			   WRITE_PIXEL( x[i], fy, p );
+		     }
+	       }
+	       else
+	       {
+		  for (i=0;i<n;i++) {
+		     int fy = Y_FLIP(y[i]);
+		     if (CLIPPIXEL( x[i], fy ))
+			WRITE_PIXEL( x[i], fy, p );
+		  }
+	       }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_WRITE_UNLOCK();
+}
+
+
+static void TAG(ReadRGBASpan)( struct gl_context *ctx,
+                               struct gl_renderbuffer *rb,
+			       GLuint n, GLint x, GLint y, void *values)
+{
+   (void) ctx;
+
+   HW_READ_LOCK()
+      {
+         GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
+	 GLint x1,n1;
+	 LOCAL_VARS;
+
+	 y = Y_FLIP(y);
+
+	 if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+	 HW_READ_CLIPLOOP()
+	    {
+	       GLint i = 0;
+	       CLIPSPAN(x,y,n,x1,n1,i);
+	       for (;n1>0;i++,x1++,n1--)
+		  READ_RGBA( rgba[i], x1, y );
+	    }
+         HW_ENDCLIPLOOP();
+      }
+   HW_READ_UNLOCK();
+}
+
+
+#if defined(GET_PTR) && \
+   defined(USE_MMX_ASM) && \
+   (((SPANTMP_PIXEL_FMT == GL_BGRA) && \
+	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)) || \
+    ((SPANTMP_PIXEL_FMT == GL_RGB) && \
+	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)))
+static void TAG2(ReadRGBASpan,_MMX)( struct gl_context *ctx,
+                                     struct gl_renderbuffer *rb,
+                                     GLuint n, GLint x, GLint y, void *values)
+{
+#ifndef USE_INNER_EMMS
+   /* The EMMS instruction is directly in-lined here because using GCC's
+    * built-in _mm_empty function was found to utterly destroy performance.
+    */
+   __asm__ __volatile__( "emms" );
+#endif
+
+   (void) ctx;
+
+   HW_READ_LOCK()
+     {
+        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
+	GLint x1,n1;
+	LOCAL_VARS;
+
+	y = Y_FLIP(y);
+
+	if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+	HW_READ_CLIPLOOP()
+	  {
+	     GLint i = 0;
+	     CLIPSPAN(x,y,n,x1,n1,i);
+
+	       {
+		  const void * src = GET_PTR( x1, y );
+#if (SPANTMP_PIXEL_FMT == GL_RGB) && \
+		  (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)
+		  _generic_read_RGBA_span_RGB565_MMX( src, rgba[i], n1 );
+#else
+		  _generic_read_RGBA_span_BGRA8888_REV_MMX( src, rgba[i], n1 );
+#endif
+	       }
+	  }
+	HW_ENDCLIPLOOP();
+     }
+   HW_READ_UNLOCK();
+#ifndef USE_INNER_EMMS
+   __asm__ __volatile__( "emms" );
+#endif
+}
+#endif
+
+
+#if defined(GET_PTR) &&	\
+   defined(USE_SSE_ASM) && \
+   (SPANTMP_PIXEL_FMT == GL_BGRA) && \
+     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+static void TAG2(ReadRGBASpan,_SSE2)( struct gl_context *ctx,
+                                      struct gl_renderbuffer *rb,
+                                      GLuint n, GLint x, GLint y,
+                                      void *values)
+{
+   (void) ctx;
+
+   HW_READ_LOCK()
+     {
+        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
+	GLint x1,n1;
+	LOCAL_VARS;
+
+	y = Y_FLIP(y);
+
+	if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+	HW_READ_CLIPLOOP()
+	  {
+	     GLint i = 0;
+	     CLIPSPAN(x,y,n,x1,n1,i);
+
+	       {
+		  const void * src = GET_PTR( x1, y );
+		  _generic_read_RGBA_span_BGRA8888_REV_SSE2( src, rgba[i], n1 );
+	       }
+	  }
+	HW_ENDCLIPLOOP();
+     }
+   HW_READ_UNLOCK();
+}
+#endif
+
+#if defined(GET_PTR) &&	\
+   defined(USE_SSE_ASM) && \
+   (SPANTMP_PIXEL_FMT == GL_BGRA) && \
+     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+static void TAG2(ReadRGBASpan,_SSE)( struct gl_context *ctx,
+                                     struct gl_renderbuffer *rb,
+                                     GLuint n, GLint x, GLint y,
+                                     void *values)
+{
+#ifndef USE_INNER_EMMS
+   /* The EMMS instruction is directly in-lined here because using GCC's
+    * built-in _mm_empty function was found to utterly destroy performance.
+    */
+   __asm__ __volatile__( "emms" );
+#endif
+
+   (void) ctx;
+
+   HW_READ_LOCK()
+     {
+        GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
+	GLint x1,n1;
+	LOCAL_VARS;
+
+	y = Y_FLIP(y);
+
+	if (DBG) fprintf(stderr, "ReadRGBASpan\n");
+
+	HW_READ_CLIPLOOP()
+	  {
+	     GLint i = 0;
+	     CLIPSPAN(x,y,n,x1,n1,i);
+
+	       {
+		  const void * src = GET_PTR( x1, y );
+		  _generic_read_RGBA_span_BGRA8888_REV_SSE( src, rgba[i], n1 );
+	       }
+	  }
+	HW_ENDCLIPLOOP();
+     }
+   HW_READ_UNLOCK();
+#ifndef USE_INNER_EMMS
+   __asm__ __volatile__( "emms" );
+#endif
+}
+#endif
+
+
+static void TAG(ReadRGBAPixels)( struct gl_context *ctx,
+                                 struct gl_renderbuffer *rb,
+				 GLuint n, const GLint x[], const GLint y[],
+				 void *values )
+{
+   (void) ctx;
+
+   HW_READ_LOCK()
+      {
+         GLubyte (*rgba)[4] = (GLubyte (*)[4]) values;
+	 GLint i;
+	 LOCAL_VARS;
+
+	 if (DBG) fprintf(stderr, "ReadRGBAPixels\n");
+
+	 HW_READ_CLIPLOOP()
+	    {
+               for (i=0;i<n;i++) {
+                  int fy = Y_FLIP( y[i] );
+                     if (CLIPPIXEL( x[i], fy ))
+                        READ_RGBA( rgba[i], x[i], fy );
+               }
+	    }
+	 HW_ENDCLIPLOOP();
+      }
+   HW_READ_UNLOCK();
+}
+
+static void TAG(InitPointers)(struct gl_renderbuffer *rb)
+{
+   rb->PutRow = TAG(WriteRGBASpan);
+   rb->PutRowRGB = TAG(WriteRGBSpan);
+   rb->PutMonoRow = TAG(WriteMonoRGBASpan);
+   rb->PutValues = TAG(WriteRGBAPixels);
+   rb->PutMonoValues = TAG(WriteMonoRGBAPixels);
+   rb->GetValues = TAG(ReadRGBAPixels);
+
+#if defined(GET_PTR)
+#if defined(USE_SSE_ASM) && \
+   (SPANTMP_PIXEL_FMT == GL_BGRA) && \
+     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+   if ( cpu_has_xmm2 ) {
+      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "SSE2" );
+      rb->GetRow = TAG2(ReadRGBASpan, _SSE2);
+   }
+   else
+#endif
+#if defined(USE_SSE_ASM) && \
+   (SPANTMP_PIXEL_FMT == GL_BGRA) && \
+     (SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)
+   if ( cpu_has_xmm ) {
+      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "SSE" );
+      rb->GetRow = TAG2(ReadRGBASpan, _SSE);
+   }
+   else
+#endif
+#if defined(USE_MMX_ASM) && \
+   (((SPANTMP_PIXEL_FMT == GL_BGRA) && \
+	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_INT_8_8_8_8_REV)) || \
+    ((SPANTMP_PIXEL_FMT == GL_RGB) && \
+	(SPANTMP_PIXEL_TYPE == GL_UNSIGNED_SHORT_5_6_5)))
+   if ( cpu_has_mmx ) {
+      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "MMX" );
+      rb->GetRow = TAG2(ReadRGBASpan, _MMX);
+   }
+   else
+#endif
+#endif /* GET_PTR */
+   {
+      if (DBG) fprintf( stderr, "Using %s version of GetRow\n", "C" );
+      rb->GetRow = TAG(ReadRGBASpan);
+   }
+
+}
+
+
+#undef INIT_MONO_PIXEL
+#undef WRITE_PIXEL
+#undef WRITE_RGBA
+#undef READ_RGBA
+#undef TAG
+#undef TAG2
+#undef GET_VALUE
+#undef PUT_VALUE
+#undef GET_PTR
+#undef SPANTMP_PIXEL_FMT
+#undef SPANTMP_PIXEL_TYPE
diff --git a/mesalib/src/mesa/drivers/dri/common/texmem.c b/mesalib/src/mesa/drivers/dri/common/texmem.c
index 1ba66133f..798ef1ee8 100644
--- a/mesalib/src/mesa/drivers/dri/common/texmem.c
+++ b/mesalib/src/mesa/drivers/dri/common/texmem.c
@@ -1,1341 +1,1341 @@
-/*

- * Copyright 2000-2001 VA Linux Systems, Inc.

- * (C) Copyright IBM Corporation 2002, 2003

- * All Rights Reserved.

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * on the rights to use, copy, modify, merge, publish, distribute, sub

- * license, and/or sell copies of the Software, and to permit persons to whom

- * the Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice (including the next

- * paragraph) shall be included in all copies or substantial portions of the

- * Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL

- * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,

- * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

- * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

- * USE OR OTHER DEALINGS IN THE SOFTWARE.

- *

- * Authors:

- *    Ian Romanick <idr@us.ibm.com>

- *    Keith Whitwell <keithw@tungstengraphics.com>

- *    Kevin E. Martin <kem@users.sourceforge.net>

- *    Gareth Hughes <gareth@nvidia.com>

- */

-

-/** \file texmem.c

- * Implements all of the device-independent texture memory management.

- * 

- * Currently, only a simple LRU texture memory management policy is

- * implemented.  In the (hopefully very near) future, better policies will be

- * implemented.  The idea is that the DRI should be able to run in one of two

- * modes.  In the default mode the DRI will dynamically attempt to discover

- * the best texture management policy for the running application.  In the

- * other mode, the user (via some sort of as yet TBD mechanism) will select

- * a texture management policy that is known to work well with the

- * application.

- */

-

-#include "main/imports.h"

-#include "main/macros.h"

-#include "main/simple_list.h"

-#include "texmem.h"

-

-

-static unsigned dummy_swap_counter;

-

-

-/**

- * Calculate \f$\log_2\f$ of a value.  This is a particularly poor

- * implementation of this function.  However, since system performance is in

- * no way dependent on this function, the slowness of the implementation is

- * irrelevent.

- * 

- * \param n Value whose \f$\log_2\f$ is to be calculated

- */

-

-static GLuint

-driLog2( GLuint n )

-{

-   GLuint log2;

-

-   for ( log2 = 1 ; n > 1 ; log2++ ) {

-      n >>= 1;

-   }

-

-   return log2;

-}

-

-

-

-

-/**

- * Determine if a texture is resident in textureable memory.  Depending on

- * the driver, this may or may not be on-card memory.  It could be AGP memory

- * or anyother type of memory from which the hardware can directly read

- * texels.

- * 

- * This function is intended to be used as the \c IsTextureResident function

- * in the device's \c dd_function_table.

- * 

- * \param ctx GL context pointer (currently unused)

- * \param texObj Texture object to be tested

- */

-

-GLboolean

-driIsTextureResident( struct gl_context * ctx, 

-		      struct gl_texture_object * texObj )

-{

-   driTextureObject * t;

-

-

-   t = (driTextureObject *) texObj->DriverData;

-   return( (t != NULL) && (t->memBlock != NULL) );

-}

-

-

-

-

-/**

- * (Re)initialize the global circular LRU list.  The last element

- * in the array (\a heap->nrRegions) is the sentinal.  Keeping it

- * at the end of the array allows the other elements of the array

- * to be addressed rationally when looking up objects at a particular

- * location in texture memory.

- * 

- * \param heap Texture heap to be reset

- */

-

-static void resetGlobalLRU( driTexHeap * heap )

-{

-   drmTextureRegionPtr list = heap->global_regions;

-   unsigned       sz = 1U << heap->logGranularity;

-   unsigned       i;

-

-   for (i = 0 ; (i+1) * sz <= heap->size ; i++) {

-      list[i].prev = i-1;

-      list[i].next = i+1;

-      list[i].age = 0;

-   }

-

-   i--;

-   list[0].prev = heap->nrRegions;

-   list[i].prev = i-1;

-   list[i].next = heap->nrRegions;

-   list[heap->nrRegions].prev = i;

-   list[heap->nrRegions].next = 0;

-   heap->global_age[0] = 0;

-}

-

-/**

- * Print out debugging information about the local texture LRU.

- *

- * \param heap Texture heap to be printed

- * \param callername Name of calling function

- */

-static void printLocalLRU( driTexHeap * heap, const char *callername  )

-{

-   driTextureObject *t;

-   unsigned sz = 1U << heap->logGranularity;

-

-   fprintf( stderr, "%s in %s:\nLocal LRU, heap %d:\n", 

-	    __FUNCTION__, callername, heap->heapId );

-

-   foreach ( t, &heap->texture_objects ) {

-      if (!t->memBlock)

-	 continue;

-      if (!t->tObj) {

-	 fprintf( stderr, "Placeholder (%p) %d at 0x%x sz 0x%x\n",

-		  (void *)t,

-		  t->memBlock->ofs / sz,

-		  t->memBlock->ofs,

-		  t->memBlock->size );

-      } else {

-	 fprintf( stderr, "Texture (%p) at 0x%x sz 0x%x\n",

-		  (void *)t,

-		  t->memBlock->ofs,

-		  t->memBlock->size );

-      }

-   }

-   foreach ( t, heap->swapped_objects ) {

-      if (!t->tObj) {

-	 fprintf( stderr, "Swapped Placeholder (%p)\n", (void *)t );

-      } else {

-	 fprintf( stderr, "Swapped Texture (%p)\n", (void *)t );

-      }

-   }

-

-   fprintf( stderr, "\n" );

-}

-

-/**

- * Print out debugging information about the global texture LRU.

- *

- * \param heap Texture heap to be printed

- * \param callername Name of calling function

- */

-static void printGlobalLRU( driTexHeap * heap, const char *callername )

-{

-   drmTextureRegionPtr list = heap->global_regions;

-   unsigned int i, j;

-

-   fprintf( stderr, "%s in %s:\nGlobal LRU, heap %d list %p:\n", 

-	    __FUNCTION__, callername, heap->heapId, (void *)list );

-

-   for ( i = 0, j = heap->nrRegions ; i < heap->nrRegions ; i++ ) {

-      fprintf( stderr, "list[%d] age %d next %d prev %d in_use %d\n",

-	       j, list[j].age, list[j].next, list[j].prev, list[j].in_use );

-      j = list[j].next;

-      if ( j == heap->nrRegions ) break;

-   }

-

-   if ( j != heap->nrRegions ) {

-      fprintf( stderr, "Loop detected in global LRU\n" );

-      for ( i = 0 ; i < heap->nrRegions ; i++ ) {

-	 fprintf( stderr, "list[%d] age %d next %d prev %d in_use %d\n",

-		  i, list[i].age, list[i].next, list[i].prev, list[i].in_use );

-      }

-   }

-

-   fprintf( stderr, "\n" );

-}

-

-

-/**

- * Called by the client whenever it touches a local texture.

- * 

- * \param t Texture object that the client has accessed

- */

-

-void driUpdateTextureLRU( driTextureObject * t )

-{

-   driTexHeap   * heap;

-   drmTextureRegionPtr list;

-   unsigned   shift;

-   unsigned   start;

-   unsigned   end;

-   unsigned   i;

-

-

-   heap = t->heap;

-   if ( heap != NULL ) {

-      shift = heap->logGranularity;

-      start = t->memBlock->ofs >> shift;

-      end = (t->memBlock->ofs + t->memBlock->size - 1) >> shift;

-

-

-      heap->local_age = ++heap->global_age[0];

-      list = heap->global_regions;

-

-

-      /* Update the context's local LRU 

-       */

-

-      move_to_head( & heap->texture_objects, t );

-

-

-      for (i = start ; i <= end ; i++) {

-	 list[i].age = heap->local_age;

-

-	 /* remove_from_list(i)

-	  */

-	 list[(unsigned)list[i].next].prev = list[i].prev;

-	 list[(unsigned)list[i].prev].next = list[i].next;

-

-	 /* insert_at_head(list, i)

-	  */

-	 list[i].prev = heap->nrRegions;

-	 list[i].next = list[heap->nrRegions].next;

-	 list[(unsigned)list[heap->nrRegions].next].prev = i;

-	 list[heap->nrRegions].next = i;

-      }

-

-      if ( 0 ) {

-	 printGlobalLRU( heap, __FUNCTION__ );

-	 printLocalLRU( heap, __FUNCTION__ );

-      }

-   }

-}

-

-

-

-

-/**

- * Keep track of swapped out texture objects.

- * 

- * \param t Texture object to be "swapped" out of its texture heap

- */

-

-void driSwapOutTextureObject( driTextureObject * t )

-{

-   unsigned   face;

-

-

-   if ( t->memBlock != NULL ) {

-      assert( t->heap != NULL );

-      mmFreeMem( t->memBlock );

-      t->memBlock = NULL;

-

-      if (t->timestamp > t->heap->timestamp)

-	 t->heap->timestamp = t->timestamp;

-

-      t->heap->texture_swaps[0]++;

-      move_to_tail( t->heap->swapped_objects, t );

-      t->heap = NULL;

-   }

-   else {

-      assert( t->heap == NULL );

-   }

-

-

-   for ( face = 0 ; face < 6 ; face++ ) {

-      t->dirty_images[face] = ~0;

-   }

-}

-

-

-

-

-/**

- * Destroy hardware state associated with texture \a t.  Calls the

- * \a destroy_texture_object method associated with the heap from which

- * \a t was allocated.

- * 

- * \param t Texture object to be destroyed

- */

-

-void driDestroyTextureObject( driTextureObject * t )

-{

-   driTexHeap * heap;

-

-

-   if ( 0 ) {

-      fprintf( stderr, "[%s:%d] freeing %p (tObj = %p, DriverData = %p)\n",

-	       __FILE__, __LINE__,

-	       (void *)t,

-	       (void *)((t != NULL) ? t->tObj : NULL),

-	       (void *)((t != NULL && t->tObj != NULL) ? t->tObj->DriverData : NULL ));

-   }

-

-   if ( t != NULL ) {

-      if ( t->memBlock ) {

-	 heap = t->heap;

-	 assert( heap != NULL );

-

-	 heap->texture_swaps[0]++;

-

-	 mmFreeMem( t->memBlock );

-	 t->memBlock = NULL;

-

-	 if (t->timestamp > t->heap->timestamp)

-	    t->heap->timestamp = t->timestamp;

-

-	 heap->destroy_texture_object( heap->driverContext, t );

-	 t->heap = NULL;

-      }

-

-      if ( t->tObj != NULL ) {

-	 assert( t->tObj->DriverData == t );

-	 t->tObj->DriverData = NULL;

-      }

-

-      remove_from_list( t );

-      FREE( t );

-   }

-

-   if ( 0 ) {

-      fprintf( stderr, "[%s:%d] done freeing %p\n", __FILE__, __LINE__, (void *)t );

-   }

-}

-

-

-

-

-/**

- * Update the local heap's representation of texture memory based on

- * data in the SAREA.  This is done each time it is detected that some other

- * direct rendering client has held the lock.  This pertains to both our local

- * textures and the textures belonging to other clients.  Keep track of other

- * client's textures by pushing a placeholder texture onto the LRU list --

- * these are denoted by \a tObj being \a NULL.

- * 

- * \param heap Heap whose state is to be updated

- * \param offset Byte offset in the heap that has been stolen

- * \param size Size, in bytes, of the stolen block

- * \param in_use Non-zero if the block is pinned/reserved by the kernel

- */

-

-static void driTexturesGone( driTexHeap * heap, int offset, int size, 

-			     int in_use )

-{

-   driTextureObject * t;

-   driTextureObject * tmp;

-

-

-   foreach_s ( t, tmp, & heap->texture_objects ) {

-      if ( (t->memBlock->ofs < (offset + size))

-	   && ((t->memBlock->ofs + t->memBlock->size) > offset) ) {

-	 /* It overlaps - kick it out.  If the texture object is just a

-	  * place holder, then destroy it all together.  Otherwise, mark

-	  * it as being swapped out.

-	  */

-

-	 if ( t->tObj != NULL ) {

-	    driSwapOutTextureObject( t );

-	 }

-	 else {

-	    driDestroyTextureObject( t );

-	 }

-      }

-   }

-

-

-   {

-      t = (driTextureObject *) CALLOC( heap->texture_object_size );

-      if ( t == NULL ) return;

-

-      t->memBlock = mmAllocMem( heap->memory_heap, size, 0, offset );

-      if ( t->memBlock == NULL ) {

-	 fprintf( stderr, "Couldn't alloc placeholder: heap %u sz %x ofs %x\n", heap->heapId,

-		  (int)size, (int)offset );

-	 mmDumpMemInfo( heap->memory_heap );

-	 FREE(t);

-	 return;

-      }

-      t->heap = heap;

-      if (in_use) 

-	 t->reserved = 1; 

-      insert_at_head( & heap->texture_objects, t );

-   }

-}

-

-

-

-

-/**

- * Called by the client on lock contention to determine whether textures have

- * been stolen.  If another client has modified a region in which we have

- * textures, then we need to figure out which of our textures have been

- * removed and update our global LRU.

- * 

- * \param heap Texture heap to be updated

- */

-

-void driAgeTextures( driTexHeap * heap )

-{

-   drmTextureRegionPtr list = heap->global_regions;

-   unsigned       sz = 1U << (heap->logGranularity);

-   unsigned       i, nr = 0;

-

-

-   /* Have to go right round from the back to ensure stuff ends up

-    * LRU in the local list...  Fix with a cursor pointer.

-    */

-

-   for (i = list[heap->nrRegions].prev ; 

-	i != heap->nrRegions && nr < heap->nrRegions ; 

-	i = list[i].prev, nr++) {

-      /* If switching texturing schemes, then the SAREA might not have been

-       * properly cleared, so we need to reset the global texture LRU.

-       */

-

-      if ( (i * sz) > heap->size ) {

-	 nr = heap->nrRegions;

-	 break;

-      }

-

-      if (list[i].age > heap->local_age) 

-	  driTexturesGone( heap, i * sz, sz, list[i].in_use); 

-   }

-

-   /* Loop or uninitialized heap detected.  Reset.

-    */

-

-   if (nr == heap->nrRegions) {

-      driTexturesGone( heap, 0, heap->size, 0);

-      resetGlobalLRU( heap );

-   }

-

-   if ( 0 ) {

-      printGlobalLRU( heap, __FUNCTION__ );

-      printLocalLRU( heap, __FUNCTION__ );

-   }

-

-   heap->local_age = heap->global_age[0];

-}

-

-

-

-

-#define INDEX_ARRAY_SIZE 6 /* I'm not aware of driver with more than 2 heaps */

-

-/**

- * Allocate memory from a texture heap to hold a texture object.  This

- * routine will attempt to allocate memory for the texture from the heaps

- * specified by \c heap_array in order.  That is, first it will try to

- * allocate from \c heap_array[0], then \c heap_array[1], and so on.

- *

- * \param heap_array Array of pointers to texture heaps to use

- * \param nr_heaps Number of heap pointer in \a heap_array

- * \param t Texture object for which space is needed

- * \return The ID of the heap from which memory was allocated, or -1 if

- *         memory could not be allocated.

- *

- * \bug The replacement policy implemented by this function is horrible.

- */

-

-

-int

-driAllocateTexture( driTexHeap * const * heap_array, unsigned nr_heaps,

-		    driTextureObject * t )

-{

-   driTexHeap       * heap;

-   driTextureObject * temp;

-   driTextureObject * cursor;

-   unsigned           id;

-

-

-   /* In case it already has texture space, initialize heap.  This also

-    * prevents GCC from issuing a warning that heap might be used

-    * uninitialized.

-    */

-

-   heap = t->heap;

-

-

-   /* Run through each of the existing heaps and try to allocate a buffer

-    * to hold the texture.

-    */

-

-   for ( id = 0 ; (t->memBlock == NULL) && (id < nr_heaps) ; id++ ) {

-      heap = heap_array[ id ];

-      if ( heap != NULL ) {

-	 t->memBlock = mmAllocMem( heap->memory_heap, t->totalSize, 

-				   heap->alignmentShift, 0 );

-      }

-   }

-

-

-   /* Kick textures out until the requested texture fits.

-    */

-

-   if ( t->memBlock == NULL ) {

-      unsigned index[INDEX_ARRAY_SIZE];

-      unsigned nrGoodHeaps = 0;

-

-      /* Trying to avoid dynamic memory allocation. If you have more

-       * heaps, increase INDEX_ARRAY_SIZE. I'm not aware of any

-       * drivers with more than 2 tex heaps. */

-      assert( nr_heaps < INDEX_ARRAY_SIZE );

-

-      /* Sort large enough heaps by duty. Insertion sort should be

-       * fast enough for such a short array. */

-      for ( id = 0 ; id < nr_heaps ; id++ ) {

-	 heap = heap_array[ id ];

-

-	 if ( heap != NULL && t->totalSize <= heap->size ) {

-	    unsigned j;

-

-	    for ( j = 0 ; j < nrGoodHeaps; j++ ) {

-	       if ( heap->duty > heap_array[ index[ j ] ]->duty )

-		  break;

-	    }

-

-	    if ( j < nrGoodHeaps ) {

-	       memmove( &index[ j+1 ], &index[ j ],

-			sizeof(index[ 0 ]) * (nrGoodHeaps - j) );

-	    }

-

-	    index[ j ] = id;

-

-	    nrGoodHeaps++;

-	 }

-      }

-

-      for ( id = 0 ; (t->memBlock == NULL) && (id < nrGoodHeaps) ; id++ ) {

-	 heap = heap_array[ index[ id ] ];

-

-	 for ( cursor = heap->texture_objects.prev, temp = cursor->prev;

-	       cursor != &heap->texture_objects ; 

-	       cursor = temp, temp = cursor->prev ) {

-	       

-	    /* The the LRU element.  If the texture is bound to one of

-	     * the texture units, then we cannot kick it out.

-	     */

-	    if ( cursor->bound || cursor->reserved ) {

-	       continue;

-	    }

-

-	    if ( cursor->memBlock )

-	       heap->duty -= cursor->memBlock->size;

-

-	    /* If this is a placeholder, there's no need to keep it */

-	    if (cursor->tObj)

-	       driSwapOutTextureObject( cursor );

-	    else

-	       driDestroyTextureObject( cursor );

-

-	    t->memBlock = mmAllocMem( heap->memory_heap, t->totalSize, 

-				      heap->alignmentShift, 0 );

-

-	    if (t->memBlock)

-	       break;

-	 }

-      }

-

-      /* Rebalance duties. If a heap kicked more data than its duty,

-       * then all other heaps get that amount multiplied with their

-       * relative weight added to their duty. The negative duty is

-       * reset to 0. In the end all heaps have a duty >= 0.

-       *

-       * CAUTION: we must not change the heap pointer here, because it

-       * is used below to update the texture object.

-       */

-      for ( id = 0 ; id < nr_heaps ; id++ )

-	 if ( heap_array[ id ] != NULL && heap_array[ id ]->duty < 0) {

-	    int duty = -heap_array[ id ]->duty;

-	    double weight = heap_array[ id ]->weight;

-	    unsigned j;

-

-	    for ( j = 0 ; j < nr_heaps ; j++ )

-	       if ( j != id && heap_array[ j ] != NULL ) {

-		  heap_array[ j ]->duty += (double) duty *

-		     heap_array[ j ]->weight / weight;

-	       }

-

-	    heap_array[ id ]->duty = 0;

-	 }

-   }

-

-

-   if ( t->memBlock != NULL ) {

-      /* id and heap->heapId may or may not be the same value here.

-       */

-

-      assert( heap != NULL );

-      assert( (t->heap == NULL) || (t->heap == heap) );

-

-      t->heap = heap;

-      return heap->heapId;

-   }

-   else {

-      assert( t->heap == NULL );

-

-      fprintf( stderr, "[%s:%d] unable to allocate texture\n",

-	       __FUNCTION__, __LINE__ );

-      return -1;

-   }

-}

-

-

-

-

-

-

-/**

- * Set the location where the texture-swap counter is stored.

- */

-

-void

-driSetTextureSwapCounterLocation( driTexHeap * heap, unsigned * counter )

-{

-   heap->texture_swaps = (counter == NULL) ? & dummy_swap_counter : counter;

-}

-

-

-

-

-/**

- * Create a new heap for texture data.

- * 

- * \param heap_id             Device-dependent heap identifier.  This value

- *                            will returned by driAllocateTexture when memory

- *                            is allocated from this heap.

- * \param context             Device-dependent driver context.  This is

- *                            supplied as the first parameter to the

- *                            \c destroy_tex_obj function.

- * \param size                Size, in bytes, of the texture region

- * \param alignmentShift      Alignment requirement for textures.  If textures 

- *                            must be allocated on a 4096 byte boundry, this

- *                            would be 12.

- * \param nr_regions          Number of regions into which this texture space

- *                            should be partitioned

- * \param global_regions      Array of \c drmTextureRegion structures in the SAREA

- * \param global_age          Pointer to the global texture age in the SAREA

- * \param swapped_objects     Pointer to the list of texture objects that are

- *                            not in texture memory (i.e., have been swapped

- *                            out).

- * \param texture_object_size Size, in bytes, of a device-dependent texture

- *                            object

- * \param destroy_tex_obj     Function used to destroy a device-dependent

- *                            texture object

- *

- * \sa driDestroyTextureHeap

- */

-

-driTexHeap *

-driCreateTextureHeap( unsigned heap_id, void * context, unsigned size,

-		      unsigned alignmentShift, unsigned nr_regions,

-		      drmTextureRegionPtr global_regions, unsigned * global_age,

-		      driTextureObject * swapped_objects, 

-		      unsigned texture_object_size,

-		      destroy_texture_object_t * destroy_tex_obj

-		    )

-{

-   driTexHeap * heap;

-   unsigned     l;

-    

-    

-   if ( 0 )

-       fprintf( stderr, "%s( %u, %p, %u, %u, %u )\n",

-		__FUNCTION__,

-		heap_id, (void *)context, size, alignmentShift, nr_regions );

-

-   heap = (driTexHeap *) CALLOC( sizeof( driTexHeap ) );

-   if ( heap != NULL ) {

-      l = driLog2( (size - 1) / nr_regions );

-      if ( l < alignmentShift )

-      {

-	 l = alignmentShift;

-      }

-

-      heap->logGranularity = l;

-      heap->size = size & ~((1L << l) - 1);

-

-      heap->memory_heap = mmInit( 0, heap->size );

-      if ( heap->memory_heap != NULL ) {

-	 heap->heapId = heap_id;

-	 heap->driverContext = context;

-

-	 heap->alignmentShift = alignmentShift;

-	 heap->nrRegions = nr_regions;

-	 heap->global_regions = global_regions;

-	 heap->global_age = global_age;

-	 heap->swapped_objects = swapped_objects;

-	 heap->texture_object_size = texture_object_size;

-	 heap->destroy_texture_object = destroy_tex_obj;

-

-	 /* Force global heap init */

-	 if (heap->global_age[0] == 0)

-	     heap->local_age = ~0;

-	 else

-	     heap->local_age = 0;

-

-	 make_empty_list( & heap->texture_objects );

-	 driSetTextureSwapCounterLocation( heap, NULL );

-

-	 heap->weight = heap->size;

-	 heap->duty = 0;

-      }

-      else {

-	 FREE( heap );

-	 heap = NULL;

-      }

-   }

-

-

-   if ( 0 )

-       fprintf( stderr, "%s returning %p\n", __FUNCTION__, (void *)heap );

-

-   return heap;

-}

-

-

-

-

-/** Destroys a texture heap

- * 

- * \param heap Texture heap to be destroyed

- */

-

-void

-driDestroyTextureHeap( driTexHeap * heap )

-{

-   driTextureObject * t;

-   driTextureObject * temp;

-

-

-   if ( heap != NULL ) {

-      foreach_s( t, temp, & heap->texture_objects ) {

-	 driDestroyTextureObject( t );

-      }

-      foreach_s( t, temp, heap->swapped_objects ) {

-	 driDestroyTextureObject( t );

-      }

-

-      mmDestroy( heap->memory_heap );

-      FREE( heap );

-   }

-}

-

-

-

-

-/****************************************************************************/

-/**

- * Determine how many texels (including all mipmap levels) would be required

- * for a texture map of size \f$2^^\c base_size_log2\f$ would require.

- *

- * \param base_size_log2 \f$log_2\f$ of the size of a side of the texture

- * \param dimensions Number of dimensions of the texture.  Either 2 or 3.

- * \param faces Number of faces of the texture.  Either 1 or 6 (for cube maps).

- * \return Number of texels

- */

-

-static unsigned

-texels_this_map_size( int base_size_log2, unsigned dimensions, unsigned faces )

-{

-   unsigned  texels;

-

-

-   assert( (faces == 1) || (faces == 6) );

-   assert( (dimensions == 2) || (dimensions == 3) );

-

-   texels = 0;

-   if ( base_size_log2 >= 0 ) {

-      texels = (1U << (dimensions * base_size_log2));

-

-      /* See http://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg03636.html

-       * for the complete explaination of why this formulation is used.

-       * Basically, the smaller mipmap levels sum to 0.333 the size of the

-       * level 0 map.  The total size is therefore the size of the map

-       * multipled by 1.333.  The +2 is there to round up.

-       */

-

-      texels = (texels * 4 * faces + 2) / 3;

-   }

-

-   return texels;

-}

-

-

-

-

-struct maps_per_heap {

-   unsigned  c[32];

-};

-

-static void

-fill_in_maximums( driTexHeap * const * heaps, unsigned nr_heaps,

-		  unsigned max_bytes_per_texel, unsigned max_size,

-		  unsigned mipmaps_at_once, unsigned dimensions,

-		  unsigned faces, struct maps_per_heap * max_textures )

-{

-   unsigned   heap;

-   unsigned   log2_size;

-   unsigned   mask;

-

-

-   /* Determine how many textures of each size can be stored in each

-    * texture heap.

-    */

-

-   for ( heap = 0 ; heap < nr_heaps ; heap++ ) {

-      if ( heaps[ heap ] == NULL ) {

-	 (void) memset( max_textures[ heap ].c, 0, 

-			sizeof( max_textures[ heap ].c ) );

-	 continue;

-      }

-

-      mask = (1U << heaps[ heap ]->logGranularity) - 1;

-

-      if ( 0 ) {

-	 fprintf( stderr, "[%s:%d] heap[%u] = %u bytes, mask = 0x%08x\n",

-		  __FILE__, __LINE__,

-		  heap, heaps[ heap ]->size, mask );

-      }

-

-      for ( log2_size = max_size ; log2_size > 0 ; log2_size-- ) {

-	 unsigned   total;

-

-

-	 /* Determine the total number of bytes required by a texture of

-	  * size log2_size.

-	  */

-

-	 total = texels_this_map_size( log2_size, dimensions, faces )

-	     - texels_this_map_size( log2_size - mipmaps_at_once,

-				     dimensions, faces );

-	 total *= max_bytes_per_texel;

-	 total = (total + mask) & ~mask;

-

-	 /* The number of textures of a given size that will fit in a heap

-	  * is equal to the size of the heap divided by the size of the

-	  * texture.

-	  */

-

-	 max_textures[ heap ].c[ log2_size ] = heaps[ heap ]->size / total;

-

-	 if ( 0 ) {

-	    fprintf( stderr, "[%s:%d] max_textures[%u].c[%02u] "

-		     "= 0x%08x / 0x%08x "

-		     "= %u (%u)\n",

-		     __FILE__, __LINE__,

-		     heap, log2_size,

-		     heaps[ heap ]->size, total,

-		     heaps[ heap ]->size / total,

-		     max_textures[ heap ].c[ log2_size ] );

-	 }

-      }

-   }

-}

-

-

-static unsigned

-get_max_size( unsigned nr_heaps,

-	      unsigned texture_units,

-	      unsigned max_size,

-	      int all_textures_one_heap,

-	      struct maps_per_heap * max_textures )

-{

-   unsigned   heap;

-   unsigned   log2_size;

-

-

-   /* Determine the largest texture size such that a texture of that size

-    * can be bound to each texture unit at the same time.  Some hardware

-    * may require that all textures be in the same texture heap for

-    * multitexturing.

-    */

-

-   for ( log2_size = max_size ; log2_size > 0 ; log2_size-- ) {

-      unsigned   total = 0;

-

-      for ( heap = 0 ; heap < nr_heaps ; heap++ )

-      {

-	 total += max_textures[ heap ].c[ log2_size ];

-

-	 if ( 0 ) {

-	    fprintf( stderr, "[%s:%d] max_textures[%u].c[%02u] = %u, "

-		     "total = %u\n", __FILE__, __LINE__, heap, log2_size,

-		     max_textures[ heap ].c[ log2_size ], total );

-	 }

-

-	 if ( (max_textures[ heap ].c[ log2_size ] >= texture_units)

-	      || (!all_textures_one_heap && (total >= texture_units)) ) {

-	    /* The number of mipmap levels is the log-base-2 of the

-	     * maximum texture size plus 1.  If the maximum texture size

-	     * is 1x1, the log-base-2 is 0 and 1 mipmap level (the base

-	     * level) is available.

-	     */

-

-	    return log2_size + 1;

-	 }

-      }

-   }

-

-   /* This should NEVER happen.  It should always be possible to have at

-    * *least* a 1x1 texture in memory!

-    */

-   assert( log2_size != 0 );

-   return 0;

-}

-

-#define SET_MAX(f,v) \

-    do { if ( max_sizes[v] != 0 ) { limits-> f = max_sizes[v]; } } while( 0 )

-

-#define SET_MAX_RECT(f,v) \

-    do { if ( max_sizes[v] != 0 ) { limits-> f = 1 << (max_sizes[v] - 1); } } while( 0 )

-

-

-/**

- * Given the amount of texture memory, the number of texture units, and the

- * maximum size of a texel, calculate the maximum texture size the driver can

- * advertise.

- * 

- * \param heaps Texture heaps for this card

- * \param nr_heap Number of texture heaps

- * \param limits OpenGL contants.  MaxTextureUnits must be set.

- * \param max_bytes_per_texel Maximum size of a single texel, in bytes

- * \param max_2D_size \f$\log_2\f$ of the maximum 2D texture size (i.e.,

- *     1024x1024 textures, this would be 10)

- * \param max_3D_size \f$\log_2\f$ of the maximum 3D texture size (i.e.,

- *     1024x1024x1024 textures, this would be 10)

- * \param max_cube_size \f$\log_2\f$ of the maximum cube texture size (i.e.,

- *     1024x1024 textures, this would be 10)

- * \param max_rect_size \f$\log_2\f$ of the maximum texture rectangle size

- *     (i.e., 1024x1024 textures, this would be 10).  This is a power-of-2

- *     even though texture rectangles need not be a power-of-2.

- * \param mipmaps_at_once Total number of mipmaps that can be used

- *     at one time.  For most hardware this will be \f$\c max_size + 1\f$.

- *     For hardware that does not support mipmapping, this will be 1.

- * \param all_textures_one_heap True if the hardware requires that all

- *     textures be in a single texture heap for multitexturing.

- * \param allow_larger_textures 0 conservative, 1 calculate limits

- *     so at least one worst-case texture can fit, 2 just use hw limits.

- */

-

-void

-driCalculateMaxTextureLevels( driTexHeap * const * heaps,

-			      unsigned nr_heaps,

-			      struct gl_constants * limits,

-			      unsigned max_bytes_per_texel,

-			      unsigned max_2D_size,

-			      unsigned max_3D_size,

-			      unsigned max_cube_size,

-			      unsigned max_rect_size,

-			      unsigned mipmaps_at_once,

-			      int all_textures_one_heap,

-			      int allow_larger_textures )

-{

-   struct maps_per_heap  max_textures[8];

-   unsigned         i;

-   const unsigned   dimensions[4] = { 2, 3, 2, 2 };

-   const unsigned   faces[4]      = { 1, 1, 6, 1 };

-   unsigned         max_sizes[4];

-   unsigned         mipmaps[4];

-

-

-   max_sizes[0] = max_2D_size;

-   max_sizes[1] = max_3D_size;

-   max_sizes[2] = max_cube_size;

-   max_sizes[3] = max_rect_size;

-

-   mipmaps[0] = mipmaps_at_once;

-   mipmaps[1] = mipmaps_at_once;

-   mipmaps[2] = mipmaps_at_once;

-   mipmaps[3] = 1;

-

-

-   /* Calculate the maximum number of texture levels in two passes.  The

-    * first pass determines how many textures of each power-of-two size

-    * (including all mipmap levels for that size) can fit in each texture

-    * heap.  The second pass finds the largest texture size that allows

-    * a texture of that size to be bound to every texture unit.

-    */

-

-   for ( i = 0 ; i < 4 ; i++ ) {

-      if ( (allow_larger_textures != 2) && (max_sizes[ i ] != 0) ) {

-	 fill_in_maximums( heaps, nr_heaps, max_bytes_per_texel,

-			   max_sizes[ i ], mipmaps[ i ],

-			   dimensions[ i ], faces[ i ],

-			   max_textures );

-

-	 max_sizes[ i ] = get_max_size( nr_heaps,

-					allow_larger_textures == 1 ?

-					1 : limits->MaxTextureUnits,

-					max_sizes[ i ],

-					all_textures_one_heap,

-					max_textures );

-      }

-      else if (max_sizes[ i ] != 0) {

-	 max_sizes[ i ] += 1;

-      }

-   }

-

-   SET_MAX( MaxTextureLevels,        0 );

-   SET_MAX( Max3DTextureLevels,      1 );

-   SET_MAX( MaxCubeTextureLevels,    2 );

-   SET_MAX_RECT( MaxTextureRectSize, 3 );

-}

-

-

-

-

-/**

- * Perform initial binding of default textures objects on a per unit, per

- * texture target basis.

- *

- * \param ctx Current OpenGL context

- * \param swapped List of swapped-out textures

- * \param targets Bit-mask of value texture targets

- */

-

-void driInitTextureObjects( struct gl_context *ctx, driTextureObject * swapped,

-			    GLuint targets )

-{

-   struct gl_texture_object *texObj;

-   GLuint tmp = ctx->Texture.CurrentUnit;

-   unsigned   i;

-

-

-   for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {

-      ctx->Texture.CurrentUnit = i;

-

-      if ( (targets & DRI_TEXMGR_DO_TEXTURE_1D) != 0 ) {

-	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_1D_INDEX];

-	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_1D, texObj );

-	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );

-      }

-

-      if ( (targets & DRI_TEXMGR_DO_TEXTURE_2D) != 0 ) {

-	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_2D_INDEX];

-	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_2D, texObj );

-	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );

-      }

-

-      if ( (targets & DRI_TEXMGR_DO_TEXTURE_3D) != 0 ) {

-	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_3D_INDEX];

-	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_3D, texObj );

-	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );

-      }

-

-      if ( (targets & DRI_TEXMGR_DO_TEXTURE_CUBE) != 0 ) {

-	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_CUBE_INDEX];

-	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_CUBE_MAP_ARB, texObj );

-	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );

-      }

-

-      if ( (targets & DRI_TEXMGR_DO_TEXTURE_RECT) != 0 ) {

-	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_RECT_INDEX];

-	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_RECTANGLE_NV, texObj );

-	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );

-      }

-   }

-

-   ctx->Texture.CurrentUnit = tmp;

-}

-

-

-

-

-/**

- * Verify that the specified texture is in the specificed heap.

- * 

- * \param tex   Texture to be tested.

- * \param heap  Texture memory heap to be tested.

- * \return True if the texture is in the heap, false otherwise.

- */

-

-static GLboolean

-check_in_heap( const driTextureObject * tex, const driTexHeap * heap )

-{

-#if 1

-   return tex->heap == heap;

-#else

-   driTextureObject * curr;

-

-   foreach( curr, & heap->texture_objects ) {

-      if ( curr == tex ) {

-	 break;

-      }

-   }

-

-   return curr == tex;

-#endif

-}

-

-

-

-/****************************************************************************/

-/**

- * Validate the consistency of a set of texture heaps.

- * Original version by Keith Whitwell in r200/r200_sanity.c.

- */

-

-GLboolean

-driValidateTextureHeaps( driTexHeap * const * texture_heaps,

-			 unsigned nr_heaps, const driTextureObject * swapped )

-{

-   driTextureObject *t;

-   unsigned  i;

-

-   for ( i = 0 ; i < nr_heaps ; i++ ) {

-      int last_end = 0;

-      unsigned textures_in_heap = 0;

-      unsigned blocks_in_mempool = 0;

-      const driTexHeap * heap = texture_heaps[i];

-      const struct mem_block *p = heap->memory_heap;

-

-      /* Check each texture object has a MemBlock, and is linked into

-       * the correct heap.  

-       *

-       * Check the texobj base address corresponds to the MemBlock

-       * range.  Check the texobj size (recalculate?) fits within

-       * the MemBlock.

-       *

-       * Count the number of texobj's using this heap.

-       */

-

-      foreach ( t, &heap->texture_objects ) {

-	 if ( !check_in_heap( t, heap ) ) {

-	    fprintf( stderr, "%s memory block for texture object @ %p not "

-		     "found in heap #%d\n",

-		     __FUNCTION__, (void *)t, i );

-	    return GL_FALSE;

-	 }

-

-

-	 if ( t->totalSize > t->memBlock->size ) {

-	    fprintf( stderr, "%s: Memory block for texture object @ %p is "

-		     "only %u bytes, but %u are required\n",

-		     __FUNCTION__, (void *)t, t->totalSize, t->memBlock->size );

-	    return GL_FALSE;

-	 }

-

-	 textures_in_heap++;

-      }

-

-      /* Validate the contents of the heap:

-       *   - Ordering

-       *   - Overlaps

-       *   - Bounds

-       */

-

-      while ( p != NULL ) {

-	 if (p->reserved) {

-	    fprintf( stderr, "%s: Block (%08x,%x), is reserved?!\n",

-		     __FUNCTION__, p->ofs, p->size );

-	    return GL_FALSE;

-	 }

-

-	 if (p->ofs != last_end) {

-	    fprintf( stderr, "%s: blocks_in_mempool = %d, last_end = %d, p->ofs = %d\n",

-		     __FUNCTION__, blocks_in_mempool, last_end, p->ofs );

-	    return GL_FALSE;

-	 }

-

-	 if (!p->reserved && !p->free) {

-	    blocks_in_mempool++;

-	 }

-

-	 last_end = p->ofs + p->size;

-	 p = p->next;

-      }

-

-      if (textures_in_heap != blocks_in_mempool) {

-	 fprintf( stderr, "%s: Different number of textures objects (%u) and "

-		  "inuse memory blocks (%u)\n", 

-		  __FUNCTION__, textures_in_heap, blocks_in_mempool );

-	 return GL_FALSE;

-      }

-

-#if 0

-      fprintf( stderr, "%s: textures_in_heap = %u\n", 

-	       __FUNCTION__, textures_in_heap );

-#endif

-   }

-

-

-   /* Check swapped texobj's have zero memblocks

-    */

-   i = 0;

-   foreach ( t, swapped ) {

-      if ( t->memBlock != NULL ) {

-	 fprintf( stderr, "%s: Swapped texobj %p has non-NULL memblock %p\n",

-		  __FUNCTION__, (void *)t, (void *)t->memBlock );

-	 return GL_FALSE;

-      }

-      i++;

-   }

-

-#if 0

-   fprintf( stderr, "%s: swapped texture count = %u\n", __FUNCTION__, i );

-#endif

-

-   return GL_TRUE;

-}

-

-

-

-

-/****************************************************************************/

-/**

- * Compute which mipmap levels that really need to be sent to the hardware.

- * This depends on the base image size, GL_TEXTURE_MIN_LOD,

- * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.

- */

-

-void

-driCalculateTextureFirstLastLevel( driTextureObject * t )

-{

-   struct gl_texture_object * const tObj = t->tObj;

-   const struct gl_texture_image * const baseImage =

-       tObj->Image[0][tObj->BaseLevel];

-

-   /* These must be signed values.  MinLod and MaxLod can be negative numbers,

-    * and having firstLevel and lastLevel as signed prevents the need for

-    * extra sign checks.

-    */

-   int   firstLevel;

-   int   lastLevel;

-

-   /* Yes, this looks overly complicated, but it's all needed.

-    */

-

-   switch (tObj->Target) {

-   case GL_TEXTURE_1D:

-   case GL_TEXTURE_2D:

-   case GL_TEXTURE_3D:

-   case GL_TEXTURE_CUBE_MAP:

-      if (tObj->Sampler.MinFilter == GL_NEAREST ||

-          tObj->Sampler.MinFilter == GL_LINEAR) {

-         /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.

-          */

-

-         firstLevel = lastLevel = tObj->BaseLevel;

-      }

-      else {

-	 firstLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MinLod + 0.5);

-	 firstLevel = MAX2(firstLevel, tObj->BaseLevel);

-	 firstLevel = MIN2(firstLevel, tObj->BaseLevel + baseImage->MaxLog2);

-	 lastLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MaxLod + 0.5);

-	 lastLevel = MAX2(lastLevel, t->tObj->BaseLevel);

-	 lastLevel = MIN2(lastLevel, t->tObj->BaseLevel + baseImage->MaxLog2);

-	 lastLevel = MIN2(lastLevel, t->tObj->MaxLevel);

-	 lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */

-      }

-      break;

-   case GL_TEXTURE_RECTANGLE_NV:

-   case GL_TEXTURE_4D_SGIS:

-      firstLevel = lastLevel = 0;

-      break;

-   default:

-      return;

-   }

-

-   /* save these values */

-   t->firstLevel = firstLevel;

-   t->lastLevel = lastLevel;

-}

-

-

-

-

-/**

- * \name DRI texture formats.  These vars are initialized to either the

- * big- or little-endian Mesa formats.

- */

-/*@{*/

-gl_format _dri_texformat_rgba8888 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_argb8888 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_rgb565 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_argb4444 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_argb1555 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_al88 = MESA_FORMAT_NONE;

-gl_format _dri_texformat_a8 = MESA_FORMAT_A8;

-gl_format _dri_texformat_i8 = MESA_FORMAT_I8;

-gl_format _dri_texformat_l8 = MESA_FORMAT_L8;

-/*@}*/

-

-

-/**

- * Initialize _dri_texformat_* vars according to whether we're on

- * a big or little endian system.

- */

-void

-driInitTextureFormats(void)

-{

-   if (_mesa_little_endian()) {

-      _dri_texformat_rgba8888	= MESA_FORMAT_RGBA8888;

-      _dri_texformat_argb8888	= MESA_FORMAT_ARGB8888;

-      _dri_texformat_rgb565	= MESA_FORMAT_RGB565;

-      _dri_texformat_argb4444	= MESA_FORMAT_ARGB4444;

-      _dri_texformat_argb1555	= MESA_FORMAT_ARGB1555;

-      _dri_texformat_al88	= MESA_FORMAT_AL88;

-   }

-   else {

-      _dri_texformat_rgba8888	= MESA_FORMAT_RGBA8888_REV;

-      _dri_texformat_argb8888	= MESA_FORMAT_ARGB8888_REV;

-      _dri_texformat_rgb565	= MESA_FORMAT_RGB565_REV;

-      _dri_texformat_argb4444	= MESA_FORMAT_ARGB4444_REV;

-      _dri_texformat_argb1555	= MESA_FORMAT_ARGB1555_REV;

-      _dri_texformat_al88	= MESA_FORMAT_AL88_REV;

-   }

-}

+/*
+ * Copyright 2000-2001 VA Linux Systems, Inc.
+ * (C) Copyright IBM Corporation 2002, 2003
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Ian Romanick <idr@us.ibm.com>
+ *    Keith Whitwell <keithw@tungstengraphics.com>
+ *    Kevin E. Martin <kem@users.sourceforge.net>
+ *    Gareth Hughes <gareth@nvidia.com>
+ */
+
+/** \file texmem.c
+ * Implements all of the device-independent texture memory management.
+ * 
+ * Currently, only a simple LRU texture memory management policy is
+ * implemented.  In the (hopefully very near) future, better policies will be
+ * implemented.  The idea is that the DRI should be able to run in one of two
+ * modes.  In the default mode the DRI will dynamically attempt to discover
+ * the best texture management policy for the running application.  In the
+ * other mode, the user (via some sort of as yet TBD mechanism) will select
+ * a texture management policy that is known to work well with the
+ * application.
+ */
+
+#include "main/imports.h"
+#include "main/macros.h"
+#include "main/simple_list.h"
+#include "texmem.h"
+
+
+static unsigned dummy_swap_counter;
+
+
+/**
+ * Calculate \f$\log_2\f$ of a value.  This is a particularly poor
+ * implementation of this function.  However, since system performance is in
+ * no way dependent on this function, the slowness of the implementation is
+ * irrelevent.
+ * 
+ * \param n Value whose \f$\log_2\f$ is to be calculated
+ */
+
+static GLuint
+driLog2( GLuint n )
+{
+   GLuint log2;
+
+   for ( log2 = 1 ; n > 1 ; log2++ ) {
+      n >>= 1;
+   }
+
+   return log2;
+}
+
+
+
+
+/**
+ * Determine if a texture is resident in textureable memory.  Depending on
+ * the driver, this may or may not be on-card memory.  It could be AGP memory
+ * or anyother type of memory from which the hardware can directly read
+ * texels.
+ * 
+ * This function is intended to be used as the \c IsTextureResident function
+ * in the device's \c dd_function_table.
+ * 
+ * \param ctx GL context pointer (currently unused)
+ * \param texObj Texture object to be tested
+ */
+
+GLboolean
+driIsTextureResident( struct gl_context * ctx, 
+		      struct gl_texture_object * texObj )
+{
+   driTextureObject * t;
+
+
+   t = (driTextureObject *) texObj->DriverData;
+   return( (t != NULL) && (t->memBlock != NULL) );
+}
+
+
+
+
+/**
+ * (Re)initialize the global circular LRU list.  The last element
+ * in the array (\a heap->nrRegions) is the sentinal.  Keeping it
+ * at the end of the array allows the other elements of the array
+ * to be addressed rationally when looking up objects at a particular
+ * location in texture memory.
+ * 
+ * \param heap Texture heap to be reset
+ */
+
+static void resetGlobalLRU( driTexHeap * heap )
+{
+   drmTextureRegionPtr list = heap->global_regions;
+   unsigned       sz = 1U << heap->logGranularity;
+   unsigned       i;
+
+   for (i = 0 ; (i+1) * sz <= heap->size ; i++) {
+      list[i].prev = i-1;
+      list[i].next = i+1;
+      list[i].age = 0;
+   }
+
+   i--;
+   list[0].prev = heap->nrRegions;
+   list[i].prev = i-1;
+   list[i].next = heap->nrRegions;
+   list[heap->nrRegions].prev = i;
+   list[heap->nrRegions].next = 0;
+   heap->global_age[0] = 0;
+}
+
+/**
+ * Print out debugging information about the local texture LRU.
+ *
+ * \param heap Texture heap to be printed
+ * \param callername Name of calling function
+ */
+static void printLocalLRU( driTexHeap * heap, const char *callername  )
+{
+   driTextureObject *t;
+   unsigned sz = 1U << heap->logGranularity;
+
+   fprintf( stderr, "%s in %s:\nLocal LRU, heap %d:\n", 
+	    __FUNCTION__, callername, heap->heapId );
+
+   foreach ( t, &heap->texture_objects ) {
+      if (!t->memBlock)
+	 continue;
+      if (!t->tObj) {
+	 fprintf( stderr, "Placeholder (%p) %d at 0x%x sz 0x%x\n",
+		  (void *)t,
+		  t->memBlock->ofs / sz,
+		  t->memBlock->ofs,
+		  t->memBlock->size );
+      } else {
+	 fprintf( stderr, "Texture (%p) at 0x%x sz 0x%x\n",
+		  (void *)t,
+		  t->memBlock->ofs,
+		  t->memBlock->size );
+      }
+   }
+   foreach ( t, heap->swapped_objects ) {
+      if (!t->tObj) {
+	 fprintf( stderr, "Swapped Placeholder (%p)\n", (void *)t );
+      } else {
+	 fprintf( stderr, "Swapped Texture (%p)\n", (void *)t );
+      }
+   }
+
+   fprintf( stderr, "\n" );
+}
+
+/**
+ * Print out debugging information about the global texture LRU.
+ *
+ * \param heap Texture heap to be printed
+ * \param callername Name of calling function
+ */
+static void printGlobalLRU( driTexHeap * heap, const char *callername )
+{
+   drmTextureRegionPtr list = heap->global_regions;
+   unsigned int i, j;
+
+   fprintf( stderr, "%s in %s:\nGlobal LRU, heap %d list %p:\n", 
+	    __FUNCTION__, callername, heap->heapId, (void *)list );
+
+   for ( i = 0, j = heap->nrRegions ; i < heap->nrRegions ; i++ ) {
+      fprintf( stderr, "list[%d] age %d next %d prev %d in_use %d\n",
+	       j, list[j].age, list[j].next, list[j].prev, list[j].in_use );
+      j = list[j].next;
+      if ( j == heap->nrRegions ) break;
+   }
+
+   if ( j != heap->nrRegions ) {
+      fprintf( stderr, "Loop detected in global LRU\n" );
+      for ( i = 0 ; i < heap->nrRegions ; i++ ) {
+	 fprintf( stderr, "list[%d] age %d next %d prev %d in_use %d\n",
+		  i, list[i].age, list[i].next, list[i].prev, list[i].in_use );
+      }
+   }
+
+   fprintf( stderr, "\n" );
+}
+
+
+/**
+ * Called by the client whenever it touches a local texture.
+ * 
+ * \param t Texture object that the client has accessed
+ */
+
+void driUpdateTextureLRU( driTextureObject * t )
+{
+   driTexHeap   * heap;
+   drmTextureRegionPtr list;
+   unsigned   shift;
+   unsigned   start;
+   unsigned   end;
+   unsigned   i;
+
+
+   heap = t->heap;
+   if ( heap != NULL ) {
+      shift = heap->logGranularity;
+      start = t->memBlock->ofs >> shift;
+      end = (t->memBlock->ofs + t->memBlock->size - 1) >> shift;
+
+
+      heap->local_age = ++heap->global_age[0];
+      list = heap->global_regions;
+
+
+      /* Update the context's local LRU 
+       */
+
+      move_to_head( & heap->texture_objects, t );
+
+
+      for (i = start ; i <= end ; i++) {
+	 list[i].age = heap->local_age;
+
+	 /* remove_from_list(i)
+	  */
+	 list[(unsigned)list[i].next].prev = list[i].prev;
+	 list[(unsigned)list[i].prev].next = list[i].next;
+
+	 /* insert_at_head(list, i)
+	  */
+	 list[i].prev = heap->nrRegions;
+	 list[i].next = list[heap->nrRegions].next;
+	 list[(unsigned)list[heap->nrRegions].next].prev = i;
+	 list[heap->nrRegions].next = i;
+      }
+
+      if ( 0 ) {
+	 printGlobalLRU( heap, __FUNCTION__ );
+	 printLocalLRU( heap, __FUNCTION__ );
+      }
+   }
+}
+
+
+
+
+/**
+ * Keep track of swapped out texture objects.
+ * 
+ * \param t Texture object to be "swapped" out of its texture heap
+ */
+
+void driSwapOutTextureObject( driTextureObject * t )
+{
+   unsigned   face;
+
+
+   if ( t->memBlock != NULL ) {
+      assert( t->heap != NULL );
+      mmFreeMem( t->memBlock );
+      t->memBlock = NULL;
+
+      if (t->timestamp > t->heap->timestamp)
+	 t->heap->timestamp = t->timestamp;
+
+      t->heap->texture_swaps[0]++;
+      move_to_tail( t->heap->swapped_objects, t );
+      t->heap = NULL;
+   }
+   else {
+      assert( t->heap == NULL );
+   }
+
+
+   for ( face = 0 ; face < 6 ; face++ ) {
+      t->dirty_images[face] = ~0;
+   }
+}
+
+
+
+
+/**
+ * Destroy hardware state associated with texture \a t.  Calls the
+ * \a destroy_texture_object method associated with the heap from which
+ * \a t was allocated.
+ * 
+ * \param t Texture object to be destroyed
+ */
+
+void driDestroyTextureObject( driTextureObject * t )
+{
+   driTexHeap * heap;
+
+
+   if ( 0 ) {
+      fprintf( stderr, "[%s:%d] freeing %p (tObj = %p, DriverData = %p)\n",
+	       __FILE__, __LINE__,
+	       (void *)t,
+	       (void *)((t != NULL) ? t->tObj : NULL),
+	       (void *)((t != NULL && t->tObj != NULL) ? t->tObj->DriverData : NULL ));
+   }
+
+   if ( t != NULL ) {
+      if ( t->memBlock ) {
+	 heap = t->heap;
+	 assert( heap != NULL );
+
+	 heap->texture_swaps[0]++;
+
+	 mmFreeMem( t->memBlock );
+	 t->memBlock = NULL;
+
+	 if (t->timestamp > t->heap->timestamp)
+	    t->heap->timestamp = t->timestamp;
+
+	 heap->destroy_texture_object( heap->driverContext, t );
+	 t->heap = NULL;
+      }
+
+      if ( t->tObj != NULL ) {
+	 assert( t->tObj->DriverData == t );
+	 t->tObj->DriverData = NULL;
+      }
+
+      remove_from_list( t );
+      FREE( t );
+   }
+
+   if ( 0 ) {
+      fprintf( stderr, "[%s:%d] done freeing %p\n", __FILE__, __LINE__, (void *)t );
+   }
+}
+
+
+
+
+/**
+ * Update the local heap's representation of texture memory based on
+ * data in the SAREA.  This is done each time it is detected that some other
+ * direct rendering client has held the lock.  This pertains to both our local
+ * textures and the textures belonging to other clients.  Keep track of other
+ * client's textures by pushing a placeholder texture onto the LRU list --
+ * these are denoted by \a tObj being \a NULL.
+ * 
+ * \param heap Heap whose state is to be updated
+ * \param offset Byte offset in the heap that has been stolen
+ * \param size Size, in bytes, of the stolen block
+ * \param in_use Non-zero if the block is pinned/reserved by the kernel
+ */
+
+static void driTexturesGone( driTexHeap * heap, int offset, int size, 
+			     int in_use )
+{
+   driTextureObject * t;
+   driTextureObject * tmp;
+
+
+   foreach_s ( t, tmp, & heap->texture_objects ) {
+      if ( (t->memBlock->ofs < (offset + size))
+	   && ((t->memBlock->ofs + t->memBlock->size) > offset) ) {
+	 /* It overlaps - kick it out.  If the texture object is just a
+	  * place holder, then destroy it all together.  Otherwise, mark
+	  * it as being swapped out.
+	  */
+
+	 if ( t->tObj != NULL ) {
+	    driSwapOutTextureObject( t );
+	 }
+	 else {
+	    driDestroyTextureObject( t );
+	 }
+      }
+   }
+
+
+   {
+      t = (driTextureObject *) CALLOC( heap->texture_object_size );
+      if ( t == NULL ) return;
+
+      t->memBlock = mmAllocMem( heap->memory_heap, size, 0, offset );
+      if ( t->memBlock == NULL ) {
+	 fprintf( stderr, "Couldn't alloc placeholder: heap %u sz %x ofs %x\n", heap->heapId,
+		  (int)size, (int)offset );
+	 mmDumpMemInfo( heap->memory_heap );
+	 FREE(t);
+	 return;
+      }
+      t->heap = heap;
+      if (in_use) 
+	 t->reserved = 1; 
+      insert_at_head( & heap->texture_objects, t );
+   }
+}
+
+
+
+
+/**
+ * Called by the client on lock contention to determine whether textures have
+ * been stolen.  If another client has modified a region in which we have
+ * textures, then we need to figure out which of our textures have been
+ * removed and update our global LRU.
+ * 
+ * \param heap Texture heap to be updated
+ */
+
+void driAgeTextures( driTexHeap * heap )
+{
+   drmTextureRegionPtr list = heap->global_regions;
+   unsigned       sz = 1U << (heap->logGranularity);
+   unsigned       i, nr = 0;
+
+
+   /* Have to go right round from the back to ensure stuff ends up
+    * LRU in the local list...  Fix with a cursor pointer.
+    */
+
+   for (i = list[heap->nrRegions].prev ; 
+	i != heap->nrRegions && nr < heap->nrRegions ; 
+	i = list[i].prev, nr++) {
+      /* If switching texturing schemes, then the SAREA might not have been
+       * properly cleared, so we need to reset the global texture LRU.
+       */
+
+      if ( (i * sz) > heap->size ) {
+	 nr = heap->nrRegions;
+	 break;
+      }
+
+      if (list[i].age > heap->local_age) 
+	  driTexturesGone( heap, i * sz, sz, list[i].in_use); 
+   }
+
+   /* Loop or uninitialized heap detected.  Reset.
+    */
+
+   if (nr == heap->nrRegions) {
+      driTexturesGone( heap, 0, heap->size, 0);
+      resetGlobalLRU( heap );
+   }
+
+   if ( 0 ) {
+      printGlobalLRU( heap, __FUNCTION__ );
+      printLocalLRU( heap, __FUNCTION__ );
+   }
+
+   heap->local_age = heap->global_age[0];
+}
+
+
+
+
+#define INDEX_ARRAY_SIZE 6 /* I'm not aware of driver with more than 2 heaps */
+
+/**
+ * Allocate memory from a texture heap to hold a texture object.  This
+ * routine will attempt to allocate memory for the texture from the heaps
+ * specified by \c heap_array in order.  That is, first it will try to
+ * allocate from \c heap_array[0], then \c heap_array[1], and so on.
+ *
+ * \param heap_array Array of pointers to texture heaps to use
+ * \param nr_heaps Number of heap pointer in \a heap_array
+ * \param t Texture object for which space is needed
+ * \return The ID of the heap from which memory was allocated, or -1 if
+ *         memory could not be allocated.
+ *
+ * \bug The replacement policy implemented by this function is horrible.
+ */
+
+
+int
+driAllocateTexture( driTexHeap * const * heap_array, unsigned nr_heaps,
+		    driTextureObject * t )
+{
+   driTexHeap       * heap;
+   driTextureObject * temp;
+   driTextureObject * cursor;
+   unsigned           id;
+
+
+   /* In case it already has texture space, initialize heap.  This also
+    * prevents GCC from issuing a warning that heap might be used
+    * uninitialized.
+    */
+
+   heap = t->heap;
+
+
+   /* Run through each of the existing heaps and try to allocate a buffer
+    * to hold the texture.
+    */
+
+   for ( id = 0 ; (t->memBlock == NULL) && (id < nr_heaps) ; id++ ) {
+      heap = heap_array[ id ];
+      if ( heap != NULL ) {
+	 t->memBlock = mmAllocMem( heap->memory_heap, t->totalSize, 
+				   heap->alignmentShift, 0 );
+      }
+   }
+
+
+   /* Kick textures out until the requested texture fits.
+    */
+
+   if ( t->memBlock == NULL ) {
+      unsigned index[INDEX_ARRAY_SIZE];
+      unsigned nrGoodHeaps = 0;
+
+      /* Trying to avoid dynamic memory allocation. If you have more
+       * heaps, increase INDEX_ARRAY_SIZE. I'm not aware of any
+       * drivers with more than 2 tex heaps. */
+      assert( nr_heaps < INDEX_ARRAY_SIZE );
+
+      /* Sort large enough heaps by duty. Insertion sort should be
+       * fast enough for such a short array. */
+      for ( id = 0 ; id < nr_heaps ; id++ ) {
+	 heap = heap_array[ id ];
+
+	 if ( heap != NULL && t->totalSize <= heap->size ) {
+	    unsigned j;
+
+	    for ( j = 0 ; j < nrGoodHeaps; j++ ) {
+	       if ( heap->duty > heap_array[ index[ j ] ]->duty )
+		  break;
+	    }
+
+	    if ( j < nrGoodHeaps ) {
+	       memmove( &index[ j+1 ], &index[ j ],
+			sizeof(index[ 0 ]) * (nrGoodHeaps - j) );
+	    }
+
+	    index[ j ] = id;
+
+	    nrGoodHeaps++;
+	 }
+      }
+
+      for ( id = 0 ; (t->memBlock == NULL) && (id < nrGoodHeaps) ; id++ ) {
+	 heap = heap_array[ index[ id ] ];
+
+	 for ( cursor = heap->texture_objects.prev, temp = cursor->prev;
+	       cursor != &heap->texture_objects ; 
+	       cursor = temp, temp = cursor->prev ) {
+	       
+	    /* The the LRU element.  If the texture is bound to one of
+	     * the texture units, then we cannot kick it out.
+	     */
+	    if ( cursor->bound || cursor->reserved ) {
+	       continue;
+	    }
+
+	    if ( cursor->memBlock )
+	       heap->duty -= cursor->memBlock->size;
+
+	    /* If this is a placeholder, there's no need to keep it */
+	    if (cursor->tObj)
+	       driSwapOutTextureObject( cursor );
+	    else
+	       driDestroyTextureObject( cursor );
+
+	    t->memBlock = mmAllocMem( heap->memory_heap, t->totalSize, 
+				      heap->alignmentShift, 0 );
+
+	    if (t->memBlock)
+	       break;
+	 }
+      }
+
+      /* Rebalance duties. If a heap kicked more data than its duty,
+       * then all other heaps get that amount multiplied with their
+       * relative weight added to their duty. The negative duty is
+       * reset to 0. In the end all heaps have a duty >= 0.
+       *
+       * CAUTION: we must not change the heap pointer here, because it
+       * is used below to update the texture object.
+       */
+      for ( id = 0 ; id < nr_heaps ; id++ )
+	 if ( heap_array[ id ] != NULL && heap_array[ id ]->duty < 0) {
+	    int duty = -heap_array[ id ]->duty;
+	    double weight = heap_array[ id ]->weight;
+	    unsigned j;
+
+	    for ( j = 0 ; j < nr_heaps ; j++ )
+	       if ( j != id && heap_array[ j ] != NULL ) {
+		  heap_array[ j ]->duty += (double) duty *
+		     heap_array[ j ]->weight / weight;
+	       }
+
+	    heap_array[ id ]->duty = 0;
+	 }
+   }
+
+
+   if ( t->memBlock != NULL ) {
+      /* id and heap->heapId may or may not be the same value here.
+       */
+
+      assert( heap != NULL );
+      assert( (t->heap == NULL) || (t->heap == heap) );
+
+      t->heap = heap;
+      return heap->heapId;
+   }
+   else {
+      assert( t->heap == NULL );
+
+      fprintf( stderr, "[%s:%d] unable to allocate texture\n",
+	       __FUNCTION__, __LINE__ );
+      return -1;
+   }
+}
+
+
+
+
+
+
+/**
+ * Set the location where the texture-swap counter is stored.
+ */
+
+void
+driSetTextureSwapCounterLocation( driTexHeap * heap, unsigned * counter )
+{
+   heap->texture_swaps = (counter == NULL) ? & dummy_swap_counter : counter;
+}
+
+
+
+
+/**
+ * Create a new heap for texture data.
+ * 
+ * \param heap_id             Device-dependent heap identifier.  This value
+ *                            will returned by driAllocateTexture when memory
+ *                            is allocated from this heap.
+ * \param context             Device-dependent driver context.  This is
+ *                            supplied as the first parameter to the
+ *                            \c destroy_tex_obj function.
+ * \param size                Size, in bytes, of the texture region
+ * \param alignmentShift      Alignment requirement for textures.  If textures 
+ *                            must be allocated on a 4096 byte boundry, this
+ *                            would be 12.
+ * \param nr_regions          Number of regions into which this texture space
+ *                            should be partitioned
+ * \param global_regions      Array of \c drmTextureRegion structures in the SAREA
+ * \param global_age          Pointer to the global texture age in the SAREA
+ * \param swapped_objects     Pointer to the list of texture objects that are
+ *                            not in texture memory (i.e., have been swapped
+ *                            out).
+ * \param texture_object_size Size, in bytes, of a device-dependent texture
+ *                            object
+ * \param destroy_tex_obj     Function used to destroy a device-dependent
+ *                            texture object
+ *
+ * \sa driDestroyTextureHeap
+ */
+
+driTexHeap *
+driCreateTextureHeap( unsigned heap_id, void * context, unsigned size,
+		      unsigned alignmentShift, unsigned nr_regions,
+		      drmTextureRegionPtr global_regions, unsigned * global_age,
+		      driTextureObject * swapped_objects, 
+		      unsigned texture_object_size,
+		      destroy_texture_object_t * destroy_tex_obj
+		    )
+{
+   driTexHeap * heap;
+   unsigned     l;
+    
+    
+   if ( 0 )
+       fprintf( stderr, "%s( %u, %p, %u, %u, %u )\n",
+		__FUNCTION__,
+		heap_id, (void *)context, size, alignmentShift, nr_regions );
+
+   heap = (driTexHeap *) CALLOC( sizeof( driTexHeap ) );
+   if ( heap != NULL ) {
+      l = driLog2( (size - 1) / nr_regions );
+      if ( l < alignmentShift )
+      {
+	 l = alignmentShift;
+      }
+
+      heap->logGranularity = l;
+      heap->size = size & ~((1L << l) - 1);
+
+      heap->memory_heap = mmInit( 0, heap->size );
+      if ( heap->memory_heap != NULL ) {
+	 heap->heapId = heap_id;
+	 heap->driverContext = context;
+
+	 heap->alignmentShift = alignmentShift;
+	 heap->nrRegions = nr_regions;
+	 heap->global_regions = global_regions;
+	 heap->global_age = global_age;
+	 heap->swapped_objects = swapped_objects;
+	 heap->texture_object_size = texture_object_size;
+	 heap->destroy_texture_object = destroy_tex_obj;
+
+	 /* Force global heap init */
+	 if (heap->global_age[0] == 0)
+	     heap->local_age = ~0;
+	 else
+	     heap->local_age = 0;
+
+	 make_empty_list( & heap->texture_objects );
+	 driSetTextureSwapCounterLocation( heap, NULL );
+
+	 heap->weight = heap->size;
+	 heap->duty = 0;
+      }
+      else {
+	 FREE( heap );
+	 heap = NULL;
+      }
+   }
+
+
+   if ( 0 )
+       fprintf( stderr, "%s returning %p\n", __FUNCTION__, (void *)heap );
+
+   return heap;
+}
+
+
+
+
+/** Destroys a texture heap
+ * 
+ * \param heap Texture heap to be destroyed
+ */
+
+void
+driDestroyTextureHeap( driTexHeap * heap )
+{
+   driTextureObject * t;
+   driTextureObject * temp;
+
+
+   if ( heap != NULL ) {
+      foreach_s( t, temp, & heap->texture_objects ) {
+	 driDestroyTextureObject( t );
+      }
+      foreach_s( t, temp, heap->swapped_objects ) {
+	 driDestroyTextureObject( t );
+      }
+
+      mmDestroy( heap->memory_heap );
+      FREE( heap );
+   }
+}
+
+
+
+
+/****************************************************************************/
+/**
+ * Determine how many texels (including all mipmap levels) would be required
+ * for a texture map of size \f$2^^\c base_size_log2\f$ would require.
+ *
+ * \param base_size_log2 \f$log_2\f$ of the size of a side of the texture
+ * \param dimensions Number of dimensions of the texture.  Either 2 or 3.
+ * \param faces Number of faces of the texture.  Either 1 or 6 (for cube maps).
+ * \return Number of texels
+ */
+
+static unsigned
+texels_this_map_size( int base_size_log2, unsigned dimensions, unsigned faces )
+{
+   unsigned  texels;
+
+
+   assert( (faces == 1) || (faces == 6) );
+   assert( (dimensions == 2) || (dimensions == 3) );
+
+   texels = 0;
+   if ( base_size_log2 >= 0 ) {
+      texels = (1U << (dimensions * base_size_log2));
+
+      /* See http://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg03636.html
+       * for the complete explaination of why this formulation is used.
+       * Basically, the smaller mipmap levels sum to 0.333 the size of the
+       * level 0 map.  The total size is therefore the size of the map
+       * multipled by 1.333.  The +2 is there to round up.
+       */
+
+      texels = (texels * 4 * faces + 2) / 3;
+   }
+
+   return texels;
+}
+
+
+
+
+struct maps_per_heap {
+   unsigned  c[32];
+};
+
+static void
+fill_in_maximums( driTexHeap * const * heaps, unsigned nr_heaps,
+		  unsigned max_bytes_per_texel, unsigned max_size,
+		  unsigned mipmaps_at_once, unsigned dimensions,
+		  unsigned faces, struct maps_per_heap * max_textures )
+{
+   unsigned   heap;
+   unsigned   log2_size;
+   unsigned   mask;
+
+
+   /* Determine how many textures of each size can be stored in each
+    * texture heap.
+    */
+
+   for ( heap = 0 ; heap < nr_heaps ; heap++ ) {
+      if ( heaps[ heap ] == NULL ) {
+	 (void) memset( max_textures[ heap ].c, 0, 
+			sizeof( max_textures[ heap ].c ) );
+	 continue;
+      }
+
+      mask = (1U << heaps[ heap ]->logGranularity) - 1;
+
+      if ( 0 ) {
+	 fprintf( stderr, "[%s:%d] heap[%u] = %u bytes, mask = 0x%08x\n",
+		  __FILE__, __LINE__,
+		  heap, heaps[ heap ]->size, mask );
+      }
+
+      for ( log2_size = max_size ; log2_size > 0 ; log2_size-- ) {
+	 unsigned   total;
+
+
+	 /* Determine the total number of bytes required by a texture of
+	  * size log2_size.
+	  */
+
+	 total = texels_this_map_size( log2_size, dimensions, faces )
+	     - texels_this_map_size( log2_size - mipmaps_at_once,
+				     dimensions, faces );
+	 total *= max_bytes_per_texel;
+	 total = (total + mask) & ~mask;
+
+	 /* The number of textures of a given size that will fit in a heap
+	  * is equal to the size of the heap divided by the size of the
+	  * texture.
+	  */
+
+	 max_textures[ heap ].c[ log2_size ] = heaps[ heap ]->size / total;
+
+	 if ( 0 ) {
+	    fprintf( stderr, "[%s:%d] max_textures[%u].c[%02u] "
+		     "= 0x%08x / 0x%08x "
+		     "= %u (%u)\n",
+		     __FILE__, __LINE__,
+		     heap, log2_size,
+		     heaps[ heap ]->size, total,
+		     heaps[ heap ]->size / total,
+		     max_textures[ heap ].c[ log2_size ] );
+	 }
+      }
+   }
+}
+
+
+static unsigned
+get_max_size( unsigned nr_heaps,
+	      unsigned texture_units,
+	      unsigned max_size,
+	      int all_textures_one_heap,
+	      struct maps_per_heap * max_textures )
+{
+   unsigned   heap;
+   unsigned   log2_size;
+
+
+   /* Determine the largest texture size such that a texture of that size
+    * can be bound to each texture unit at the same time.  Some hardware
+    * may require that all textures be in the same texture heap for
+    * multitexturing.
+    */
+
+   for ( log2_size = max_size ; log2_size > 0 ; log2_size-- ) {
+      unsigned   total = 0;
+
+      for ( heap = 0 ; heap < nr_heaps ; heap++ )
+      {
+	 total += max_textures[ heap ].c[ log2_size ];
+
+	 if ( 0 ) {
+	    fprintf( stderr, "[%s:%d] max_textures[%u].c[%02u] = %u, "
+		     "total = %u\n", __FILE__, __LINE__, heap, log2_size,
+		     max_textures[ heap ].c[ log2_size ], total );
+	 }
+
+	 if ( (max_textures[ heap ].c[ log2_size ] >= texture_units)
+	      || (!all_textures_one_heap && (total >= texture_units)) ) {
+	    /* The number of mipmap levels is the log-base-2 of the
+	     * maximum texture size plus 1.  If the maximum texture size
+	     * is 1x1, the log-base-2 is 0 and 1 mipmap level (the base
+	     * level) is available.
+	     */
+
+	    return log2_size + 1;
+	 }
+      }
+   }
+
+   /* This should NEVER happen.  It should always be possible to have at
+    * *least* a 1x1 texture in memory!
+    */
+   assert( log2_size != 0 );
+   return 0;
+}
+
+#define SET_MAX(f,v) \
+    do { if ( max_sizes[v] != 0 ) { limits-> f = max_sizes[v]; } } while( 0 )
+
+#define SET_MAX_RECT(f,v) \
+    do { if ( max_sizes[v] != 0 ) { limits-> f = 1 << (max_sizes[v] - 1); } } while( 0 )
+
+
+/**
+ * Given the amount of texture memory, the number of texture units, and the
+ * maximum size of a texel, calculate the maximum texture size the driver can
+ * advertise.
+ * 
+ * \param heaps Texture heaps for this card
+ * \param nr_heap Number of texture heaps
+ * \param limits OpenGL contants.  MaxTextureUnits must be set.
+ * \param max_bytes_per_texel Maximum size of a single texel, in bytes
+ * \param max_2D_size \f$\log_2\f$ of the maximum 2D texture size (i.e.,
+ *     1024x1024 textures, this would be 10)
+ * \param max_3D_size \f$\log_2\f$ of the maximum 3D texture size (i.e.,
+ *     1024x1024x1024 textures, this would be 10)
+ * \param max_cube_size \f$\log_2\f$ of the maximum cube texture size (i.e.,
+ *     1024x1024 textures, this would be 10)
+ * \param max_rect_size \f$\log_2\f$ of the maximum texture rectangle size
+ *     (i.e., 1024x1024 textures, this would be 10).  This is a power-of-2
+ *     even though texture rectangles need not be a power-of-2.
+ * \param mipmaps_at_once Total number of mipmaps that can be used
+ *     at one time.  For most hardware this will be \f$\c max_size + 1\f$.
+ *     For hardware that does not support mipmapping, this will be 1.
+ * \param all_textures_one_heap True if the hardware requires that all
+ *     textures be in a single texture heap for multitexturing.
+ * \param allow_larger_textures 0 conservative, 1 calculate limits
+ *     so at least one worst-case texture can fit, 2 just use hw limits.
+ */
+
+void
+driCalculateMaxTextureLevels( driTexHeap * const * heaps,
+			      unsigned nr_heaps,
+			      struct gl_constants * limits,
+			      unsigned max_bytes_per_texel,
+			      unsigned max_2D_size,
+			      unsigned max_3D_size,
+			      unsigned max_cube_size,
+			      unsigned max_rect_size,
+			      unsigned mipmaps_at_once,
+			      int all_textures_one_heap,
+			      int allow_larger_textures )
+{
+   struct maps_per_heap  max_textures[8];
+   unsigned         i;
+   const unsigned   dimensions[4] = { 2, 3, 2, 2 };
+   const unsigned   faces[4]      = { 1, 1, 6, 1 };
+   unsigned         max_sizes[4];
+   unsigned         mipmaps[4];
+
+
+   max_sizes[0] = max_2D_size;
+   max_sizes[1] = max_3D_size;
+   max_sizes[2] = max_cube_size;
+   max_sizes[3] = max_rect_size;
+
+   mipmaps[0] = mipmaps_at_once;
+   mipmaps[1] = mipmaps_at_once;
+   mipmaps[2] = mipmaps_at_once;
+   mipmaps[3] = 1;
+
+
+   /* Calculate the maximum number of texture levels in two passes.  The
+    * first pass determines how many textures of each power-of-two size
+    * (including all mipmap levels for that size) can fit in each texture
+    * heap.  The second pass finds the largest texture size that allows
+    * a texture of that size to be bound to every texture unit.
+    */
+
+   for ( i = 0 ; i < 4 ; i++ ) {
+      if ( (allow_larger_textures != 2) && (max_sizes[ i ] != 0) ) {
+	 fill_in_maximums( heaps, nr_heaps, max_bytes_per_texel,
+			   max_sizes[ i ], mipmaps[ i ],
+			   dimensions[ i ], faces[ i ],
+			   max_textures );
+
+	 max_sizes[ i ] = get_max_size( nr_heaps,
+					allow_larger_textures == 1 ?
+					1 : limits->MaxTextureUnits,
+					max_sizes[ i ],
+					all_textures_one_heap,
+					max_textures );
+      }
+      else if (max_sizes[ i ] != 0) {
+	 max_sizes[ i ] += 1;
+      }
+   }
+
+   SET_MAX( MaxTextureLevels,        0 );
+   SET_MAX( Max3DTextureLevels,      1 );
+   SET_MAX( MaxCubeTextureLevels,    2 );
+   SET_MAX_RECT( MaxTextureRectSize, 3 );
+}
+
+
+
+
+/**
+ * Perform initial binding of default textures objects on a per unit, per
+ * texture target basis.
+ *
+ * \param ctx Current OpenGL context
+ * \param swapped List of swapped-out textures
+ * \param targets Bit-mask of value texture targets
+ */
+
+void driInitTextureObjects( struct gl_context *ctx, driTextureObject * swapped,
+			    GLuint targets )
+{
+   struct gl_texture_object *texObj;
+   GLuint tmp = ctx->Texture.CurrentUnit;
+   unsigned   i;
+
+
+   for ( i = 0 ; i < ctx->Const.MaxTextureUnits ; i++ ) {
+      ctx->Texture.CurrentUnit = i;
+
+      if ( (targets & DRI_TEXMGR_DO_TEXTURE_1D) != 0 ) {
+	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_1D_INDEX];
+	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_1D, texObj );
+	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );
+      }
+
+      if ( (targets & DRI_TEXMGR_DO_TEXTURE_2D) != 0 ) {
+	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_2D_INDEX];
+	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_2D, texObj );
+	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );
+      }
+
+      if ( (targets & DRI_TEXMGR_DO_TEXTURE_3D) != 0 ) {
+	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_3D_INDEX];
+	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_3D, texObj );
+	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );
+      }
+
+      if ( (targets & DRI_TEXMGR_DO_TEXTURE_CUBE) != 0 ) {
+	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_CUBE_INDEX];
+	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_CUBE_MAP_ARB, texObj );
+	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );
+      }
+
+      if ( (targets & DRI_TEXMGR_DO_TEXTURE_RECT) != 0 ) {
+	 texObj = ctx->Texture.Unit[i].CurrentTex[TEXTURE_RECT_INDEX];
+	 ctx->Driver.BindTexture( ctx, GL_TEXTURE_RECTANGLE_NV, texObj );
+	 move_to_tail( swapped, (driTextureObject *) texObj->DriverData );
+      }
+   }
+
+   ctx->Texture.CurrentUnit = tmp;
+}
+
+
+
+
+/**
+ * Verify that the specified texture is in the specificed heap.
+ * 
+ * \param tex   Texture to be tested.
+ * \param heap  Texture memory heap to be tested.
+ * \return True if the texture is in the heap, false otherwise.
+ */
+
+static GLboolean
+check_in_heap( const driTextureObject * tex, const driTexHeap * heap )
+{
+#if 1
+   return tex->heap == heap;
+#else
+   driTextureObject * curr;
+
+   foreach( curr, & heap->texture_objects ) {
+      if ( curr == tex ) {
+	 break;
+      }
+   }
+
+   return curr == tex;
+#endif
+}
+
+
+
+/****************************************************************************/
+/**
+ * Validate the consistency of a set of texture heaps.
+ * Original version by Keith Whitwell in r200/r200_sanity.c.
+ */
+
+GLboolean
+driValidateTextureHeaps( driTexHeap * const * texture_heaps,
+			 unsigned nr_heaps, const driTextureObject * swapped )
+{
+   driTextureObject *t;
+   unsigned  i;
+
+   for ( i = 0 ; i < nr_heaps ; i++ ) {
+      int last_end = 0;
+      unsigned textures_in_heap = 0;
+      unsigned blocks_in_mempool = 0;
+      const driTexHeap * heap = texture_heaps[i];
+      const struct mem_block *p = heap->memory_heap;
+
+      /* Check each texture object has a MemBlock, and is linked into
+       * the correct heap.  
+       *
+       * Check the texobj base address corresponds to the MemBlock
+       * range.  Check the texobj size (recalculate?) fits within
+       * the MemBlock.
+       *
+       * Count the number of texobj's using this heap.
+       */
+
+      foreach ( t, &heap->texture_objects ) {
+	 if ( !check_in_heap( t, heap ) ) {
+	    fprintf( stderr, "%s memory block for texture object @ %p not "
+		     "found in heap #%d\n",
+		     __FUNCTION__, (void *)t, i );
+	    return GL_FALSE;
+	 }
+
+
+	 if ( t->totalSize > t->memBlock->size ) {
+	    fprintf( stderr, "%s: Memory block for texture object @ %p is "
+		     "only %u bytes, but %u are required\n",
+		     __FUNCTION__, (void *)t, t->totalSize, t->memBlock->size );
+	    return GL_FALSE;
+	 }
+
+	 textures_in_heap++;
+      }
+
+      /* Validate the contents of the heap:
+       *   - Ordering
+       *   - Overlaps
+       *   - Bounds
+       */
+
+      while ( p != NULL ) {
+	 if (p->reserved) {
+	    fprintf( stderr, "%s: Block (%08x,%x), is reserved?!\n",
+		     __FUNCTION__, p->ofs, p->size );
+	    return GL_FALSE;
+	 }
+
+	 if (p->ofs != last_end) {
+	    fprintf( stderr, "%s: blocks_in_mempool = %d, last_end = %d, p->ofs = %d\n",
+		     __FUNCTION__, blocks_in_mempool, last_end, p->ofs );
+	    return GL_FALSE;
+	 }
+
+	 if (!p->reserved && !p->free) {
+	    blocks_in_mempool++;
+	 }
+
+	 last_end = p->ofs + p->size;
+	 p = p->next;
+      }
+
+      if (textures_in_heap != blocks_in_mempool) {
+	 fprintf( stderr, "%s: Different number of textures objects (%u) and "
+		  "inuse memory blocks (%u)\n", 
+		  __FUNCTION__, textures_in_heap, blocks_in_mempool );
+	 return GL_FALSE;
+      }
+
+#if 0
+      fprintf( stderr, "%s: textures_in_heap = %u\n", 
+	       __FUNCTION__, textures_in_heap );
+#endif
+   }
+
+
+   /* Check swapped texobj's have zero memblocks
+    */
+   i = 0;
+   foreach ( t, swapped ) {
+      if ( t->memBlock != NULL ) {
+	 fprintf( stderr, "%s: Swapped texobj %p has non-NULL memblock %p\n",
+		  __FUNCTION__, (void *)t, (void *)t->memBlock );
+	 return GL_FALSE;
+      }
+      i++;
+   }
+
+#if 0
+   fprintf( stderr, "%s: swapped texture count = %u\n", __FUNCTION__, i );
+#endif
+
+   return GL_TRUE;
+}
+
+
+
+
+/****************************************************************************/
+/**
+ * Compute which mipmap levels that really need to be sent to the hardware.
+ * This depends on the base image size, GL_TEXTURE_MIN_LOD,
+ * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
+ */
+
+void
+driCalculateTextureFirstLastLevel( driTextureObject * t )
+{
+   struct gl_texture_object * const tObj = t->tObj;
+   const struct gl_texture_image * const baseImage =
+       tObj->Image[0][tObj->BaseLevel];
+
+   /* These must be signed values.  MinLod and MaxLod can be negative numbers,
+    * and having firstLevel and lastLevel as signed prevents the need for
+    * extra sign checks.
+    */
+   int   firstLevel;
+   int   lastLevel;
+
+   /* Yes, this looks overly complicated, but it's all needed.
+    */
+
+   switch (tObj->Target) {
+   case GL_TEXTURE_1D:
+   case GL_TEXTURE_2D:
+   case GL_TEXTURE_3D:
+   case GL_TEXTURE_CUBE_MAP:
+      if (tObj->Sampler.MinFilter == GL_NEAREST ||
+          tObj->Sampler.MinFilter == GL_LINEAR) {
+         /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
+          */
+
+         firstLevel = lastLevel = tObj->BaseLevel;
+      }
+      else {
+	 firstLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MinLod + 0.5);
+	 firstLevel = MAX2(firstLevel, tObj->BaseLevel);
+	 firstLevel = MIN2(firstLevel, tObj->BaseLevel + baseImage->MaxLog2);
+	 lastLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MaxLod + 0.5);
+	 lastLevel = MAX2(lastLevel, t->tObj->BaseLevel);
+	 lastLevel = MIN2(lastLevel, t->tObj->BaseLevel + baseImage->MaxLog2);
+	 lastLevel = MIN2(lastLevel, t->tObj->MaxLevel);
+	 lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
+      }
+      break;
+   case GL_TEXTURE_RECTANGLE_NV:
+   case GL_TEXTURE_4D_SGIS:
+      firstLevel = lastLevel = 0;
+      break;
+   default:
+      return;
+   }
+
+   /* save these values */
+   t->firstLevel = firstLevel;
+   t->lastLevel = lastLevel;
+}
+
+
+
+
+/**
+ * \name DRI texture formats.  These vars are initialized to either the
+ * big- or little-endian Mesa formats.
+ */
+/*@{*/
+gl_format _dri_texformat_rgba8888 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_argb8888 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_rgb565 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_argb4444 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_argb1555 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_al88 = MESA_FORMAT_NONE;
+gl_format _dri_texformat_a8 = MESA_FORMAT_A8;
+gl_format _dri_texformat_i8 = MESA_FORMAT_I8;
+gl_format _dri_texformat_l8 = MESA_FORMAT_L8;
+/*@}*/
+
+
+/**
+ * Initialize _dri_texformat_* vars according to whether we're on
+ * a big or little endian system.
+ */
+void
+driInitTextureFormats(void)
+{
+   if (_mesa_little_endian()) {
+      _dri_texformat_rgba8888	= MESA_FORMAT_RGBA8888;
+      _dri_texformat_argb8888	= MESA_FORMAT_ARGB8888;
+      _dri_texformat_rgb565	= MESA_FORMAT_RGB565;
+      _dri_texformat_argb4444	= MESA_FORMAT_ARGB4444;
+      _dri_texformat_argb1555	= MESA_FORMAT_ARGB1555;
+      _dri_texformat_al88	= MESA_FORMAT_AL88;
+   }
+   else {
+      _dri_texformat_rgba8888	= MESA_FORMAT_RGBA8888_REV;
+      _dri_texformat_argb8888	= MESA_FORMAT_ARGB8888_REV;
+      _dri_texformat_rgb565	= MESA_FORMAT_RGB565_REV;
+      _dri_texformat_argb4444	= MESA_FORMAT_ARGB4444_REV;
+      _dri_texformat_argb1555	= MESA_FORMAT_ARGB1555_REV;
+      _dri_texformat_al88	= MESA_FORMAT_AL88_REV;
+   }
+}
diff --git a/mesalib/src/mesa/drivers/dri/swrast/swrast.c b/mesalib/src/mesa/drivers/dri/swrast/swrast.c
index 63b3fe94c..13a13eade 100644
--- a/mesalib/src/mesa/drivers/dri/swrast/swrast.c
+++ b/mesalib/src/mesa/drivers/dri/swrast/swrast.c
@@ -1,820 +1,820 @@
-/*

- * Copyright 2008, 2010 George Sapountzis <gsapountzis@gmail.com>

- *

- * Permission is hereby granted, free of charge, to any person obtaining a

- * copy of this software and associated documentation files (the "Software"),

- * to deal in the Software without restriction, including without limitation

- * the rights to use, copy, modify, merge, publish, distribute, sublicense,

- * and/or sell copies of the Software, and to permit persons to whom the

- * Software is furnished to do so, subject to the following conditions:

- *

- * The above copyright notice and this permission notice shall be included

- * in all copies or substantial portions of the Software.

- *

- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

- */

-

-/*

- * DRI software rasterizer

- *

- * This is the mesa swrast module packaged into a DRI driver structure.

- *

- * The front-buffer is allocated by the loader. The loader provides read/write

- * callbacks for access to the front-buffer. The driver uses a scratch row for

- * front-buffer rendering to avoid repeated calls to the loader.

- *

- * The back-buffer is allocated by the driver and is private.

- */

-

-#ifdef _MSC_VER

-#define WIN32_LEAN_AND_MEAN 1

-#include <windows.h>

-#endif

-

-#include "main/context.h"

-#include "main/extensions.h"

-#include "main/formats.h"

-#include "main/framebuffer.h"

-#include "main/imports.h"

-#include "main/renderbuffer.h"

-#include "swrast/swrast.h"

-#include "swrast_setup/swrast_setup.h"

-#include "tnl/tnl.h"

-#include "tnl/t_context.h"

-#include "tnl/t_pipeline.h"

-#include "vbo/vbo.h"

-#include "drivers/common/driverfuncs.h"

-#include "drivers/common/meta.h"

-#include "utils.h"

-

-#include "main/teximage.h"

-#include "main/texformat.h"

-#include "main/texstate.h"

-

-#include "swrast_priv.h"

-

-

-/**

- * Screen and config-related functions

- */

-

-static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target,

-				GLint texture_format, __DRIdrawable *dPriv)

-{

-    struct dri_context *dri_ctx;

-    int x, y, w, h;

-    __DRIscreen *sPriv = dPriv->driScreenPriv;

-    struct gl_texture_unit *texUnit;

-    struct gl_texture_object *texObj;

-    struct gl_texture_image *texImage;

-    uint32_t internalFormat;

-    gl_format texFormat;

-

-    dri_ctx = pDRICtx->driverPrivate;

-

-    internalFormat = (texture_format == __DRI_TEXTURE_FORMAT_RGB ? 3 : 4);

-

-    texUnit = _mesa_get_current_tex_unit(&dri_ctx->Base);

-    texObj = _mesa_select_tex_object(&dri_ctx->Base, texUnit, target);

-    texImage = _mesa_get_tex_image(&dri_ctx->Base, texObj, target, 0);

-

-    _mesa_lock_texture(&dri_ctx->Base, texObj);

-

-    sPriv->swrast_loader->getDrawableInfo(dPriv, &x, &y, &w, &h, dPriv->loaderPrivate);

-

-    if (texture_format == __DRI_TEXTURE_FORMAT_RGB)

-	texFormat = MESA_FORMAT_XRGB8888;

-    else

-	texFormat = MESA_FORMAT_ARGB8888;

-

-    _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage,

-			       w, h, 1, 0, internalFormat, texFormat);

-

-    sPriv->swrast_loader->getImage(dPriv, x, y, w, h, (char *)texImage->Data,

-				   dPriv->loaderPrivate);

-

-    _mesa_unlock_texture(&dri_ctx->Base, texObj);

-}

-

-static void swrastSetTexBuffer(__DRIcontext *pDRICtx, GLint target,

-			       __DRIdrawable *dPriv)

-{

-    swrastSetTexBuffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);

-}

-

-static const __DRItexBufferExtension swrastTexBufferExtension = {

-    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },

-    swrastSetTexBuffer,

-    swrastSetTexBuffer2,

-};

-

-static const __DRIextension *dri_screen_extensions[] = {

-    &swrastTexBufferExtension.base,

-    NULL

-};

-

-static __DRIconfig **

-swrastFillInModes(__DRIscreen *psp,

-		  unsigned pixel_bits, unsigned depth_bits,

-		  unsigned stencil_bits, GLboolean have_back_buffer)

-{

-    __DRIconfig **configs;

-    unsigned depth_buffer_factor;

-    unsigned back_buffer_factor;

-    GLenum fb_format;

-    GLenum fb_type;

-

-    /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't

-     * support pageflipping at all.

-     */

-    static const GLenum back_buffer_modes[] = {

-	GLX_NONE, GLX_SWAP_UNDEFINED_OML

-    };

-

-    uint8_t depth_bits_array[4];

-    uint8_t stencil_bits_array[4];

-    uint8_t msaa_samples_array[1];

-

-    (void) psp;

-    (void) have_back_buffer;

-

-    depth_bits_array[0] = 0;

-    depth_bits_array[1] = 0;

-    depth_bits_array[2] = depth_bits;

-    depth_bits_array[3] = depth_bits;

-

-    /* Just like with the accumulation buffer, always provide some modes

-     * with a stencil buffer.

-     */

-    stencil_bits_array[0] = 0;

-    stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;

-    stencil_bits_array[2] = 0;

-    stencil_bits_array[3] = (stencil_bits == 0) ? 8 : stencil_bits;

-

-    msaa_samples_array[0] = 0;

-

-    depth_buffer_factor = 4;

-    back_buffer_factor = 2;

-

-    switch (pixel_bits) {

-    case 8:

-	fb_format = GL_RGB;

-	fb_type = GL_UNSIGNED_BYTE_2_3_3_REV;

-	break;

-    case 16:

-	fb_format = GL_RGB;

-	fb_type = GL_UNSIGNED_SHORT_5_6_5;

-	break;

-    case 24:

-	fb_format = GL_BGR;

-	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;

-	break;

-    case 32:

-	fb_format = GL_BGRA;

-	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;

-	break;

-    default:

-	fprintf(stderr, "[%s:%u] bad depth %d\n", __FUNCTION__, __LINE__,

-		pixel_bits);

-	return NULL;

-    }

-

-    configs = driCreateConfigs(fb_format, fb_type,

-			       depth_bits_array, stencil_bits_array,

-			       depth_buffer_factor, back_buffer_modes,

-			       back_buffer_factor, msaa_samples_array, 1,

-			       GL_TRUE);

-    if (configs == NULL) {

-	fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __FUNCTION__,

-		__LINE__);

-	return NULL;

-    }

-

-    return configs;

-}

-

-static const __DRIconfig **

-dri_init_screen(__DRIscreen * psp)

-{

-    __DRIconfig **configs8, **configs16, **configs24, **configs32;

-

-    TRACE;

-

-    psp->extensions = dri_screen_extensions;

-

-    configs8  = swrastFillInModes(psp,  8,  8, 0, 1);

-    configs16 = swrastFillInModes(psp, 16, 16, 0, 1);

-    configs24 = swrastFillInModes(psp, 24, 24, 8, 1);

-    configs32 = swrastFillInModes(psp, 32, 24, 8, 1);

-

-    configs16 = driConcatConfigs(configs8, configs16);

-    configs24 = driConcatConfigs(configs16, configs24);

-    configs32 = driConcatConfigs(configs24, configs32);

-

-    return (const __DRIconfig **)configs32;

-}

-

-static void

-dri_destroy_screen(__DRIscreen * sPriv)

-{

-    TRACE;

-    (void) sPriv;

-}

-

-

-/**

- * Framebuffer and renderbuffer-related functions.

- */

-

-static GLuint

-choose_pixel_format(const struct gl_config *v)

-{

-    int depth = v->rgbBits;

-

-    if (depth == 32

-	&& v->redMask   == 0xff0000

-	&& v->greenMask == 0x00ff00

-	&& v->blueMask  == 0x0000ff)

-	return PF_A8R8G8B8;

-    else if (depth == 24

-	     && v->redMask   == 0xff0000

-	     && v->greenMask == 0x00ff00

-	     && v->blueMask  == 0x0000ff)

-	return PF_X8R8G8B8;

-    else if (depth == 16

-	     && v->redMask   == 0xf800

-	     && v->greenMask == 0x07e0

-	     && v->blueMask  == 0x001f)

-	return PF_R5G6B5;

-    else if (depth == 8

-	     && v->redMask   == 0x07

-	     && v->greenMask == 0x38

-	     && v->blueMask  == 0xc0)

-	return PF_R3G3B2;

-

-    _mesa_problem( NULL, "unexpected format in %s", __FUNCTION__ );

-    return 0;

-}

-

-static void

-swrast_delete_renderbuffer(struct gl_renderbuffer *rb)

-{

-    TRACE;

-

-    free(rb->Data);

-    free(rb);

-}

-

-/* see bytes_per_line in libGL */

-static INLINE int

-bytes_per_line(unsigned pitch_bits, unsigned mul)

-{

-   unsigned mask = mul - 1;

-

-   return ((pitch_bits + mask) & ~mask) / 8;

-}

-

-static GLboolean

-swrast_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,

-			   GLenum internalFormat, GLuint width, GLuint height)

-{

-    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);

-

-    TRACE;

-

-    (void) ctx;

-    (void) internalFormat;

-

-    rb->Data = NULL;

-    rb->Width = width;

-    rb->Height = height;

-

-    xrb->pitch = bytes_per_line(width * xrb->bpp, 32);

-

-    return GL_TRUE;

-}

-

-static GLboolean

-swrast_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,

-			  GLenum internalFormat, GLuint width, GLuint height)

-{

-    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);

-

-    TRACE;

-

-    free(rb->Data);

-

-    swrast_alloc_front_storage(ctx, rb, internalFormat, width, height);

-

-    rb->Data = malloc(height * xrb->pitch);

-

-    return GL_TRUE;

-}

-

-static struct swrast_renderbuffer *

-swrast_new_renderbuffer(const struct gl_config *visual, GLboolean front)

-{

-    struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb);

-    GLuint pixel_format;

-

-    TRACE;

-

-    if (!xrb)

-	return NULL;

-

-    _mesa_init_renderbuffer(&xrb->Base, 0);

-

-    pixel_format = choose_pixel_format(visual);

-

-    xrb->Base.Delete = swrast_delete_renderbuffer;

-    if (front) {

-	xrb->Base.AllocStorage = swrast_alloc_front_storage;

-	swrast_set_span_funcs_front(xrb, pixel_format);

-    }

-    else {

-	xrb->Base.AllocStorage = swrast_alloc_back_storage;

-	swrast_set_span_funcs_back(xrb, pixel_format);

-    }

-

-    switch (pixel_format) {

-    case PF_A8R8G8B8:

-	xrb->Base.Format = MESA_FORMAT_ARGB8888;

-	xrb->Base.InternalFormat = GL_RGBA;

-	xrb->Base._BaseFormat = GL_RGBA;

-	xrb->Base.DataType = GL_UNSIGNED_BYTE;

-	xrb->bpp = 32;

-	break;

-    case PF_X8R8G8B8:

-	xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */

-	xrb->Base.InternalFormat = GL_RGB;

-	xrb->Base._BaseFormat = GL_RGB;

-	xrb->Base.DataType = GL_UNSIGNED_BYTE;

-	xrb->bpp = 32;

-	break;

-    case PF_R5G6B5:

-	xrb->Base.Format = MESA_FORMAT_RGB565;

-	xrb->Base.InternalFormat = GL_RGB;

-	xrb->Base._BaseFormat = GL_RGB;

-	xrb->Base.DataType = GL_UNSIGNED_BYTE;

-	xrb->bpp = 16;

-	break;

-    case PF_R3G3B2:

-	xrb->Base.Format = MESA_FORMAT_RGB332;

-	xrb->Base.InternalFormat = GL_RGB;

-	xrb->Base._BaseFormat = GL_RGB;

-	xrb->Base.DataType = GL_UNSIGNED_BYTE;

-	xrb->bpp = 8;

-	break;

-    default:

-	return NULL;

-    }

-

-    return xrb;

-}

-

-static GLboolean

-dri_create_buffer(__DRIscreen * sPriv,

-		  __DRIdrawable * dPriv,

-		  const struct gl_config * visual, GLboolean isPixmap)

-{

-    struct dri_drawable *drawable = NULL;

-    struct gl_framebuffer *fb;

-    struct swrast_renderbuffer *frontrb, *backrb;

-

-    TRACE;

-

-    (void) sPriv;

-    (void) isPixmap;

-

-    drawable = CALLOC_STRUCT(dri_drawable);

-    if (drawable == NULL)

-	goto drawable_fail;

-

-    dPriv->driverPrivate = drawable;

-    drawable->dPriv = dPriv;

-

-    drawable->row = malloc(MAX_WIDTH * 4);

-    if (drawable->row == NULL)

-	goto drawable_fail;

-

-    fb = &drawable->Base;

-

-    /* basic framebuffer setup */

-    _mesa_initialize_window_framebuffer(fb, visual);

-

-    /* add front renderbuffer */

-    frontrb = swrast_new_renderbuffer(visual, GL_TRUE);

-    _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontrb->Base);

-

-    /* add back renderbuffer */

-    if (visual->doubleBufferMode) {

-	backrb = swrast_new_renderbuffer(visual, GL_FALSE);

-	_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backrb->Base);

-    }

-

-    /* add software renderbuffers */

-    _mesa_add_soft_renderbuffers(fb,

-				 GL_FALSE, /* color */

-				 visual->haveDepthBuffer,

-				 visual->haveStencilBuffer,

-				 visual->haveAccumBuffer,

-				 GL_FALSE, /* alpha */

-				 GL_FALSE /* aux bufs */);

-

-    return GL_TRUE;

-

-drawable_fail:

-

-    if (drawable)

-	free(drawable->row);

-

-    FREE(drawable);

-

-    return GL_FALSE;

-}

-

-static void

-dri_destroy_buffer(__DRIdrawable * dPriv)

-{

-    TRACE;

-

-    if (dPriv) {

-	struct dri_drawable *drawable = dri_drawable(dPriv);

-	struct gl_framebuffer *fb;

-

-	free(drawable->row);

-

-	fb = &drawable->Base;

-

-	fb->DeletePending = GL_TRUE;

-	_mesa_reference_framebuffer(&fb, NULL);

-    }

-}

-

-static void

-dri_swap_buffers(__DRIdrawable * dPriv)

-{

-    __DRIscreen *sPriv = dPriv->driScreenPriv;

-

-    GET_CURRENT_CONTEXT(ctx);

-

-    struct dri_drawable *drawable = dri_drawable(dPriv);

-    struct gl_framebuffer *fb;

-    struct swrast_renderbuffer *frontrb, *backrb;

-

-    TRACE;

-

-    fb = &drawable->Base;

-

-    frontrb =

-	swrast_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);

-    backrb =

-	swrast_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);

-

-    /* check for signle-buffered */

-    if (backrb == NULL)

-	return;

-

-    /* check if swapping currently bound buffer */

-    if (ctx && ctx->DrawBuffer == fb) {

-	/* flush pending rendering */

-	_mesa_notifySwapBuffers(ctx);

-    }

-

-    sPriv->swrast_loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,

-				   0, 0,

-				   frontrb->Base.Width,

-				   frontrb->Base.Height,

-				   backrb->Base.Data,

-				   dPriv->loaderPrivate);

-}

-

-

-/**

- * General device driver functions.

- */

-

-static void

-get_window_size( struct gl_framebuffer *fb, GLsizei *w, GLsizei *h )

-{

-    __DRIdrawable *dPriv = swrast_drawable(fb)->dPriv;

-    __DRIscreen *sPriv = dPriv->driScreenPriv;

-    int x, y;

-

-    sPriv->swrast_loader->getDrawableInfo(dPriv,

-					  &x, &y, w, h,

-					  dPriv->loaderPrivate);

-}

-

-static void

-swrast_check_and_update_window_size( struct gl_context *ctx, struct gl_framebuffer *fb )

-{

-    GLsizei width, height;

-

-    get_window_size(fb, &width, &height);

-    if (fb->Width != width || fb->Height != height) {

-	_mesa_resize_framebuffer(ctx, fb, width, height);

-    }

-}

-

-static const GLubyte *

-get_string(struct gl_context *ctx, GLenum pname)

-{

-    (void) ctx;

-    switch (pname) {

-	case GL_VENDOR:

-	    return (const GLubyte *) "Mesa Project";

-	case GL_RENDERER:

-	    return (const GLubyte *) "Software Rasterizer";

-	default:

-	    return NULL;

-    }

-}

-

-static void

-update_state( struct gl_context *ctx, GLuint new_state )

-{

-    /* not much to do here - pass it on */

-    _swrast_InvalidateState( ctx, new_state );

-    _swsetup_InvalidateState( ctx, new_state );

-    _vbo_InvalidateState( ctx, new_state );

-    _tnl_InvalidateState( ctx, new_state );

-}

-

-static void

-viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h)

-{

-    struct gl_framebuffer *draw = ctx->WinSysDrawBuffer;

-    struct gl_framebuffer *read = ctx->WinSysReadBuffer;

-

-    (void) x;

-    (void) y;

-    (void) w;

-    (void) h;

-    swrast_check_and_update_window_size(ctx, draw);

-    swrast_check_and_update_window_size(ctx, read);

-}

-

-static gl_format swrastChooseTextureFormat(struct gl_context * ctx,

-					   GLint internalFormat,

-					   GLenum format,

-					   GLenum type)

-{

-    if (internalFormat == GL_RGB)

-	return MESA_FORMAT_XRGB8888;

-    return _mesa_choose_tex_format(ctx, internalFormat, format, type);

-}

-

-static void

-swrast_init_driver_functions(struct dd_function_table *driver)

-{

-    driver->GetString = get_string;

-    driver->UpdateState = update_state;

-    driver->GetBufferSize = NULL;

-    driver->Viewport = viewport;

-    driver->ChooseTextureFormat = swrastChooseTextureFormat;

-}

-

-static const char *es2_extensions[] = {

-   /* Used by mesa internally (cf all_mesa_extensions in ../common/utils.c) */

-   "GL_ARB_draw_buffers",

-   "GL_ARB_multisample",

-   "GL_ARB_texture_compression",

-   "GL_ARB_transpose_matrix",

-   "GL_ARB_vertex_buffer_object",

-   "GL_ARB_window_pos",

-   "GL_EXT_blend_func_separate",

-   "GL_EXT_compiled_vertex_array",

-   "GL_EXT_framebuffer_blit",

-   "GL_EXT_multi_draw_arrays",

-   "GL_EXT_polygon_offset",

-   "GL_EXT_texture_object",

-   "GL_EXT_vertex_array",

-   "GL_IBM_multimode_draw_arrays",

-   "GL_MESA_window_pos",

-   "GL_NV_vertex_program",

-

-   /* Required by GLES2 */

-   "GL_ARB_fragment_program",

-   "GL_ARB_fragment_shader",

-   "GL_ARB_multitexture",

-   "GL_ARB_shader_objects",

-   "GL_ARB_texture_cube_map",

-   "GL_ARB_texture_mirrored_repeat",

-   "GL_ARB_texture_non_power_of_two",

-   "GL_ARB_vertex_shader",

-   "GL_EXT_blend_color",

-   "GL_EXT_blend_equation_separate",

-   "GL_EXT_blend_minmax",

-   "GL_EXT_blend_subtract",

-   "GL_EXT_stencil_wrap",

-

-   /* Optional GLES2 */

-   "GL_ARB_framebuffer_object",

-   "GL_EXT_texture_filter_anisotropic",

-   "GL_ARB_depth_texture",

-   "GL_EXT_packed_depth_stencil",

-   "GL_EXT_framebuffer_object",

-   NULL,

-};

-

-static void

-InitExtensionsES2(struct gl_context *ctx)

-{

-   int i;

-

-   for (i = 0; es2_extensions[i]; i++)

-      _mesa_enable_extension(ctx, es2_extensions[i]);

-}

-

-/**

- * Context-related functions.

- */

-

-static GLboolean

-dri_create_context(gl_api api,

-		   const struct gl_config * visual,

-		   __DRIcontext * cPriv, void *sharedContextPrivate)

-{

-    struct dri_context *ctx = NULL;

-    struct dri_context *share = (struct dri_context *)sharedContextPrivate;

-    struct gl_context *mesaCtx = NULL;

-    struct gl_context *sharedCtx = NULL;

-    struct dd_function_table functions;

-

-    TRACE;

-

-    ctx = CALLOC_STRUCT(dri_context);

-    if (ctx == NULL)

-	goto context_fail;

-

-    cPriv->driverPrivate = ctx;

-    ctx->cPriv = cPriv;

-

-    /* build table of device driver functions */

-    _mesa_init_driver_functions(&functions);

-    swrast_init_driver_functions(&functions);

-

-    if (share) {

-	sharedCtx = &share->Base;

-    }

-

-    mesaCtx = &ctx->Base;

-

-    /* basic context setup */

-    if (!_mesa_initialize_context(mesaCtx, api, visual, sharedCtx, &functions, (void *) cPriv)) {

-	goto context_fail;

-    }

-

-    /* do bounds checking to prevent segfaults and server crashes! */

-    mesaCtx->Const.CheckArrayBounds = GL_TRUE;

-

-    /* create module contexts */

-    _swrast_CreateContext( mesaCtx );

-    _vbo_CreateContext( mesaCtx );

-    _tnl_CreateContext( mesaCtx );

-    _swsetup_CreateContext( mesaCtx );

-    _swsetup_Wakeup( mesaCtx );

-

-    /* use default TCL pipeline */

-    {

-       TNLcontext *tnl = TNL_CONTEXT(mesaCtx);

-       tnl->Driver.RunPipeline = _tnl_run_pipeline;

-    }

-

-    _mesa_meta_init(mesaCtx);

-    _mesa_enable_sw_extensions(mesaCtx);

-

-    switch (api) {

-    case API_OPENGL:

-        _mesa_enable_1_3_extensions(mesaCtx);

-        _mesa_enable_1_4_extensions(mesaCtx);

-        _mesa_enable_1_5_extensions(mesaCtx);

-        _mesa_enable_2_0_extensions(mesaCtx);

-        _mesa_enable_2_1_extensions(mesaCtx);

-        break;

-    case API_OPENGLES:

-        _mesa_enable_1_3_extensions(mesaCtx);

-        _mesa_enable_1_4_extensions(mesaCtx);

-        _mesa_enable_1_5_extensions(mesaCtx);

-

-        break;

-    case API_OPENGLES2:

-        InitExtensionsES2( mesaCtx);

-        break;

-    }

-

-    return GL_TRUE;

-

-context_fail:

-

-    FREE(ctx);

-

-    return GL_FALSE;

-}

-

-static void

-dri_destroy_context(__DRIcontext * cPriv)

-{

-    TRACE;

-

-    if (cPriv) {

-	struct dri_context *ctx = dri_context(cPriv);

-	struct gl_context *mesaCtx;

-

-	mesaCtx = &ctx->Base;

-

-        _mesa_meta_free(mesaCtx);

-	_swsetup_DestroyContext( mesaCtx );

-	_swrast_DestroyContext( mesaCtx );

-	_tnl_DestroyContext( mesaCtx );

-	_vbo_DestroyContext( mesaCtx );

-	_mesa_destroy_context( mesaCtx );

-    }

-}

-

-static GLboolean

-dri_make_current(__DRIcontext * cPriv,

-		 __DRIdrawable * driDrawPriv,

-		 __DRIdrawable * driReadPriv)

-{

-    struct gl_context *mesaCtx;

-    struct gl_framebuffer *mesaDraw;

-    struct gl_framebuffer *mesaRead;

-    TRACE;

-

-    if (cPriv) {

-	struct dri_context *ctx = dri_context(cPriv);

-	struct dri_drawable *draw;

-	struct dri_drawable *read;

-

-	if (!driDrawPriv || !driReadPriv)

-	    return GL_FALSE;

-

-	draw = dri_drawable(driDrawPriv);

-	read = dri_drawable(driReadPriv);

-	mesaCtx = &ctx->Base;

-	mesaDraw = &draw->Base;

-	mesaRead = &read->Base;

-

-	/* check for same context and buffer */

-	if (mesaCtx == _mesa_get_current_context()

-	    && mesaCtx->DrawBuffer == mesaDraw

-	    && mesaCtx->ReadBuffer == mesaRead) {

-	    return GL_TRUE;

-	}

-

-	_glapi_check_multithread();

-

-	swrast_check_and_update_window_size(mesaCtx, mesaDraw);

-	if (mesaRead != mesaDraw)

-	    swrast_check_and_update_window_size(mesaCtx, mesaRead);

-

-	_mesa_make_current( mesaCtx,

-			    mesaDraw,

-			    mesaRead );

-    }

-    else {

-	/* unbind */

-	_mesa_make_current( NULL, NULL, NULL );

-    }

-

-    return GL_TRUE;

-}

-

-static GLboolean

-dri_unbind_context(__DRIcontext * cPriv)

-{

-    TRACE;

-    (void) cPriv;

-

-    /* Unset current context and dispath table */

-    _mesa_make_current(NULL, NULL, NULL);

-

-    return GL_TRUE;

-}

-

-

-const struct __DriverAPIRec driDriverAPI = {

-    /*.InitScreen = */dri_init_screen,

-    /*.DestroyScreen = */dri_destroy_screen,

-    /*.CreateContext = */dri_create_context,

-    /*.DestroyContext = */dri_destroy_context,

-    /*.CreateBuffer = */dri_create_buffer,

-    /*.DestroyBuffer = */dri_destroy_buffer,

-    /*.SwapBuffers = */dri_swap_buffers,

-    /*.MakeCurrent = */dri_make_current,

-    /*.UnbindContext = */dri_unbind_context,

-};

-

-/* This is the table of extensions that the loader will dlsym() for. */

-PUBLIC const __DRIextension *__driDriverExtensions[] = {

-    &driCoreExtension.base,

-    &driSWRastExtension.base,

-    NULL

-};

+/*
+ * Copyright 2008, 2010 George Sapountzis <gsapountzis@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * DRI software rasterizer
+ *
+ * This is the mesa swrast module packaged into a DRI driver structure.
+ *
+ * The front-buffer is allocated by the loader. The loader provides read/write
+ * callbacks for access to the front-buffer. The driver uses a scratch row for
+ * front-buffer rendering to avoid repeated calls to the loader.
+ *
+ * The back-buffer is allocated by the driver and is private.
+ */
+
+#ifdef _MSC_VER
+#define WIN32_LEAN_AND_MEAN 1
+#include <windows.h>
+#endif
+
+#include "main/context.h"
+#include "main/extensions.h"
+#include "main/formats.h"
+#include "main/framebuffer.h"
+#include "main/imports.h"
+#include "main/renderbuffer.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+#include "vbo/vbo.h"
+#include "drivers/common/driverfuncs.h"
+#include "drivers/common/meta.h"
+#include "utils.h"
+
+#include "main/teximage.h"
+#include "main/texformat.h"
+#include "main/texstate.h"
+
+#include "swrast_priv.h"
+
+
+/**
+ * Screen and config-related functions
+ */
+
+static void swrastSetTexBuffer2(__DRIcontext *pDRICtx, GLint target,
+				GLint texture_format, __DRIdrawable *dPriv)
+{
+    struct dri_context *dri_ctx;
+    int x, y, w, h;
+    __DRIscreen *sPriv = dPriv->driScreenPriv;
+    struct gl_texture_unit *texUnit;
+    struct gl_texture_object *texObj;
+    struct gl_texture_image *texImage;
+    uint32_t internalFormat;
+    gl_format texFormat;
+
+    dri_ctx = pDRICtx->driverPrivate;
+
+    internalFormat = (texture_format == __DRI_TEXTURE_FORMAT_RGB ? 3 : 4);
+
+    texUnit = _mesa_get_current_tex_unit(&dri_ctx->Base);
+    texObj = _mesa_select_tex_object(&dri_ctx->Base, texUnit, target);
+    texImage = _mesa_get_tex_image(&dri_ctx->Base, texObj, target, 0);
+
+    _mesa_lock_texture(&dri_ctx->Base, texObj);
+
+    sPriv->swrast_loader->getDrawableInfo(dPriv, &x, &y, &w, &h, dPriv->loaderPrivate);
+
+    if (texture_format == __DRI_TEXTURE_FORMAT_RGB)
+	texFormat = MESA_FORMAT_XRGB8888;
+    else
+	texFormat = MESA_FORMAT_ARGB8888;
+
+    _mesa_init_teximage_fields(&dri_ctx->Base, target, texImage,
+			       w, h, 1, 0, internalFormat, texFormat);
+
+    sPriv->swrast_loader->getImage(dPriv, x, y, w, h, (char *)texImage->Data,
+				   dPriv->loaderPrivate);
+
+    _mesa_unlock_texture(&dri_ctx->Base, texObj);
+}
+
+static void swrastSetTexBuffer(__DRIcontext *pDRICtx, GLint target,
+			       __DRIdrawable *dPriv)
+{
+    swrastSetTexBuffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);
+}
+
+static const __DRItexBufferExtension swrastTexBufferExtension = {
+    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
+    swrastSetTexBuffer,
+    swrastSetTexBuffer2,
+};
+
+static const __DRIextension *dri_screen_extensions[] = {
+    &swrastTexBufferExtension.base,
+    NULL
+};
+
+static __DRIconfig **
+swrastFillInModes(__DRIscreen *psp,
+		  unsigned pixel_bits, unsigned depth_bits,
+		  unsigned stencil_bits, GLboolean have_back_buffer)
+{
+    __DRIconfig **configs;
+    unsigned depth_buffer_factor;
+    unsigned back_buffer_factor;
+    GLenum fb_format;
+    GLenum fb_type;
+
+    /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't
+     * support pageflipping at all.
+     */
+    static const GLenum back_buffer_modes[] = {
+	GLX_NONE, GLX_SWAP_UNDEFINED_OML
+    };
+
+    uint8_t depth_bits_array[4];
+    uint8_t stencil_bits_array[4];
+    uint8_t msaa_samples_array[1];
+
+    (void) psp;
+    (void) have_back_buffer;
+
+    depth_bits_array[0] = 0;
+    depth_bits_array[1] = 0;
+    depth_bits_array[2] = depth_bits;
+    depth_bits_array[3] = depth_bits;
+
+    /* Just like with the accumulation buffer, always provide some modes
+     * with a stencil buffer.
+     */
+    stencil_bits_array[0] = 0;
+    stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;
+    stencil_bits_array[2] = 0;
+    stencil_bits_array[3] = (stencil_bits == 0) ? 8 : stencil_bits;
+
+    msaa_samples_array[0] = 0;
+
+    depth_buffer_factor = 4;
+    back_buffer_factor = 2;
+
+    switch (pixel_bits) {
+    case 8:
+	fb_format = GL_RGB;
+	fb_type = GL_UNSIGNED_BYTE_2_3_3_REV;
+	break;
+    case 16:
+	fb_format = GL_RGB;
+	fb_type = GL_UNSIGNED_SHORT_5_6_5;
+	break;
+    case 24:
+	fb_format = GL_BGR;
+	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+	break;
+    case 32:
+	fb_format = GL_BGRA;
+	fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
+	break;
+    default:
+	fprintf(stderr, "[%s:%u] bad depth %d\n", __FUNCTION__, __LINE__,
+		pixel_bits);
+	return NULL;
+    }
+
+    configs = driCreateConfigs(fb_format, fb_type,
+			       depth_bits_array, stencil_bits_array,
+			       depth_buffer_factor, back_buffer_modes,
+			       back_buffer_factor, msaa_samples_array, 1,
+			       GL_TRUE);
+    if (configs == NULL) {
+	fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __FUNCTION__,
+		__LINE__);
+	return NULL;
+    }
+
+    return configs;
+}
+
+static const __DRIconfig **
+dri_init_screen(__DRIscreen * psp)
+{
+    __DRIconfig **configs8, **configs16, **configs24, **configs32;
+
+    TRACE;
+
+    psp->extensions = dri_screen_extensions;
+
+    configs8  = swrastFillInModes(psp,  8,  8, 0, 1);
+    configs16 = swrastFillInModes(psp, 16, 16, 0, 1);
+    configs24 = swrastFillInModes(psp, 24, 24, 8, 1);
+    configs32 = swrastFillInModes(psp, 32, 24, 8, 1);
+
+    configs16 = driConcatConfigs(configs8, configs16);
+    configs24 = driConcatConfigs(configs16, configs24);
+    configs32 = driConcatConfigs(configs24, configs32);
+
+    return (const __DRIconfig **)configs32;
+}
+
+static void
+dri_destroy_screen(__DRIscreen * sPriv)
+{
+    TRACE;
+    (void) sPriv;
+}
+
+
+/**
+ * Framebuffer and renderbuffer-related functions.
+ */
+
+static GLuint
+choose_pixel_format(const struct gl_config *v)
+{
+    int depth = v->rgbBits;
+
+    if (depth == 32
+	&& v->redMask   == 0xff0000
+	&& v->greenMask == 0x00ff00
+	&& v->blueMask  == 0x0000ff)
+	return PF_A8R8G8B8;
+    else if (depth == 24
+	     && v->redMask   == 0xff0000
+	     && v->greenMask == 0x00ff00
+	     && v->blueMask  == 0x0000ff)
+	return PF_X8R8G8B8;
+    else if (depth == 16
+	     && v->redMask   == 0xf800
+	     && v->greenMask == 0x07e0
+	     && v->blueMask  == 0x001f)
+	return PF_R5G6B5;
+    else if (depth == 8
+	     && v->redMask   == 0x07
+	     && v->greenMask == 0x38
+	     && v->blueMask  == 0xc0)
+	return PF_R3G3B2;
+
+    _mesa_problem( NULL, "unexpected format in %s", __FUNCTION__ );
+    return 0;
+}
+
+static void
+swrast_delete_renderbuffer(struct gl_renderbuffer *rb)
+{
+    TRACE;
+
+    free(rb->Data);
+    free(rb);
+}
+
+/* see bytes_per_line in libGL */
+static INLINE int
+bytes_per_line(unsigned pitch_bits, unsigned mul)
+{
+   unsigned mask = mul - 1;
+
+   return ((pitch_bits + mask) & ~mask) / 8;
+}
+
+static GLboolean
+swrast_alloc_front_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
+			   GLenum internalFormat, GLuint width, GLuint height)
+{
+    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);
+
+    TRACE;
+
+    (void) ctx;
+    (void) internalFormat;
+
+    rb->Data = NULL;
+    rb->Width = width;
+    rb->Height = height;
+
+    xrb->pitch = bytes_per_line(width * xrb->bpp, 32);
+
+    return GL_TRUE;
+}
+
+static GLboolean
+swrast_alloc_back_storage(struct gl_context *ctx, struct gl_renderbuffer *rb,
+			  GLenum internalFormat, GLuint width, GLuint height)
+{
+    struct swrast_renderbuffer *xrb = swrast_renderbuffer(rb);
+
+    TRACE;
+
+    free(rb->Data);
+
+    swrast_alloc_front_storage(ctx, rb, internalFormat, width, height);
+
+    rb->Data = malloc(height * xrb->pitch);
+
+    return GL_TRUE;
+}
+
+static struct swrast_renderbuffer *
+swrast_new_renderbuffer(const struct gl_config *visual, GLboolean front)
+{
+    struct swrast_renderbuffer *xrb = calloc(1, sizeof *xrb);
+    GLuint pixel_format;
+
+    TRACE;
+
+    if (!xrb)
+	return NULL;
+
+    _mesa_init_renderbuffer(&xrb->Base, 0);
+
+    pixel_format = choose_pixel_format(visual);
+
+    xrb->Base.Delete = swrast_delete_renderbuffer;
+    if (front) {
+	xrb->Base.AllocStorage = swrast_alloc_front_storage;
+	swrast_set_span_funcs_front(xrb, pixel_format);
+    }
+    else {
+	xrb->Base.AllocStorage = swrast_alloc_back_storage;
+	swrast_set_span_funcs_back(xrb, pixel_format);
+    }
+
+    switch (pixel_format) {
+    case PF_A8R8G8B8:
+	xrb->Base.Format = MESA_FORMAT_ARGB8888;
+	xrb->Base.InternalFormat = GL_RGBA;
+	xrb->Base._BaseFormat = GL_RGBA;
+	xrb->Base.DataType = GL_UNSIGNED_BYTE;
+	xrb->bpp = 32;
+	break;
+    case PF_X8R8G8B8:
+	xrb->Base.Format = MESA_FORMAT_ARGB8888; /* XXX */
+	xrb->Base.InternalFormat = GL_RGB;
+	xrb->Base._BaseFormat = GL_RGB;
+	xrb->Base.DataType = GL_UNSIGNED_BYTE;
+	xrb->bpp = 32;
+	break;
+    case PF_R5G6B5:
+	xrb->Base.Format = MESA_FORMAT_RGB565;
+	xrb->Base.InternalFormat = GL_RGB;
+	xrb->Base._BaseFormat = GL_RGB;
+	xrb->Base.DataType = GL_UNSIGNED_BYTE;
+	xrb->bpp = 16;
+	break;
+    case PF_R3G3B2:
+	xrb->Base.Format = MESA_FORMAT_RGB332;
+	xrb->Base.InternalFormat = GL_RGB;
+	xrb->Base._BaseFormat = GL_RGB;
+	xrb->Base.DataType = GL_UNSIGNED_BYTE;
+	xrb->bpp = 8;
+	break;
+    default:
+	return NULL;
+    }
+
+    return xrb;
+}
+
+static GLboolean
+dri_create_buffer(__DRIscreen * sPriv,
+		  __DRIdrawable * dPriv,
+		  const struct gl_config * visual, GLboolean isPixmap)
+{
+    struct dri_drawable *drawable = NULL;
+    struct gl_framebuffer *fb;
+    struct swrast_renderbuffer *frontrb, *backrb;
+
+    TRACE;
+
+    (void) sPriv;
+    (void) isPixmap;
+
+    drawable = CALLOC_STRUCT(dri_drawable);
+    if (drawable == NULL)
+	goto drawable_fail;
+
+    dPriv->driverPrivate = drawable;
+    drawable->dPriv = dPriv;
+
+    drawable->row = malloc(MAX_WIDTH * 4);
+    if (drawable->row == NULL)
+	goto drawable_fail;
+
+    fb = &drawable->Base;
+
+    /* basic framebuffer setup */
+    _mesa_initialize_window_framebuffer(fb, visual);
+
+    /* add front renderbuffer */
+    frontrb = swrast_new_renderbuffer(visual, GL_TRUE);
+    _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontrb->Base);
+
+    /* add back renderbuffer */
+    if (visual->doubleBufferMode) {
+	backrb = swrast_new_renderbuffer(visual, GL_FALSE);
+	_mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backrb->Base);
+    }
+
+    /* add software renderbuffers */
+    _mesa_add_soft_renderbuffers(fb,
+				 GL_FALSE, /* color */
+				 visual->haveDepthBuffer,
+				 visual->haveStencilBuffer,
+				 visual->haveAccumBuffer,
+				 GL_FALSE, /* alpha */
+				 GL_FALSE /* aux bufs */);
+
+    return GL_TRUE;
+
+drawable_fail:
+
+    if (drawable)
+	free(drawable->row);
+
+    FREE(drawable);
+
+    return GL_FALSE;
+}
+
+static void
+dri_destroy_buffer(__DRIdrawable * dPriv)
+{
+    TRACE;
+
+    if (dPriv) {
+	struct dri_drawable *drawable = dri_drawable(dPriv);
+	struct gl_framebuffer *fb;
+
+	free(drawable->row);
+
+	fb = &drawable->Base;
+
+	fb->DeletePending = GL_TRUE;
+	_mesa_reference_framebuffer(&fb, NULL);
+    }
+}
+
+static void
+dri_swap_buffers(__DRIdrawable * dPriv)
+{
+    __DRIscreen *sPriv = dPriv->driScreenPriv;
+
+    GET_CURRENT_CONTEXT(ctx);
+
+    struct dri_drawable *drawable = dri_drawable(dPriv);
+    struct gl_framebuffer *fb;
+    struct swrast_renderbuffer *frontrb, *backrb;
+
+    TRACE;
+
+    fb = &drawable->Base;
+
+    frontrb =
+	swrast_renderbuffer(fb->Attachment[BUFFER_FRONT_LEFT].Renderbuffer);
+    backrb =
+	swrast_renderbuffer(fb->Attachment[BUFFER_BACK_LEFT].Renderbuffer);
+
+    /* check for signle-buffered */
+    if (backrb == NULL)
+	return;
+
+    /* check if swapping currently bound buffer */
+    if (ctx && ctx->DrawBuffer == fb) {
+	/* flush pending rendering */
+	_mesa_notifySwapBuffers(ctx);
+    }
+
+    sPriv->swrast_loader->putImage(dPriv, __DRI_SWRAST_IMAGE_OP_SWAP,
+				   0, 0,
+				   frontrb->Base.Width,
+				   frontrb->Base.Height,
+				   backrb->Base.Data,
+				   dPriv->loaderPrivate);
+}
+
+
+/**
+ * General device driver functions.
+ */
+
+static void
+get_window_size( struct gl_framebuffer *fb, GLsizei *w, GLsizei *h )
+{
+    __DRIdrawable *dPriv = swrast_drawable(fb)->dPriv;
+    __DRIscreen *sPriv = dPriv->driScreenPriv;
+    int x, y;
+
+    sPriv->swrast_loader->getDrawableInfo(dPriv,
+					  &x, &y, w, h,
+					  dPriv->loaderPrivate);
+}
+
+static void
+swrast_check_and_update_window_size( struct gl_context *ctx, struct gl_framebuffer *fb )
+{
+    GLsizei width, height;
+
+    get_window_size(fb, &width, &height);
+    if (fb->Width != width || fb->Height != height) {
+	_mesa_resize_framebuffer(ctx, fb, width, height);
+    }
+}
+
+static const GLubyte *
+get_string(struct gl_context *ctx, GLenum pname)
+{
+    (void) ctx;
+    switch (pname) {
+	case GL_VENDOR:
+	    return (const GLubyte *) "Mesa Project";
+	case GL_RENDERER:
+	    return (const GLubyte *) "Software Rasterizer";
+	default:
+	    return NULL;
+    }
+}
+
+static void
+update_state( struct gl_context *ctx, GLuint new_state )
+{
+    /* not much to do here - pass it on */
+    _swrast_InvalidateState( ctx, new_state );
+    _swsetup_InvalidateState( ctx, new_state );
+    _vbo_InvalidateState( ctx, new_state );
+    _tnl_InvalidateState( ctx, new_state );
+}
+
+static void
+viewport(struct gl_context *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
+{
+    struct gl_framebuffer *draw = ctx->WinSysDrawBuffer;
+    struct gl_framebuffer *read = ctx->WinSysReadBuffer;
+
+    (void) x;
+    (void) y;
+    (void) w;
+    (void) h;
+    swrast_check_and_update_window_size(ctx, draw);
+    swrast_check_and_update_window_size(ctx, read);
+}
+
+static gl_format swrastChooseTextureFormat(struct gl_context * ctx,
+					   GLint internalFormat,
+					   GLenum format,
+					   GLenum type)
+{
+    if (internalFormat == GL_RGB)
+	return MESA_FORMAT_XRGB8888;
+    return _mesa_choose_tex_format(ctx, internalFormat, format, type);
+}
+
+static void
+swrast_init_driver_functions(struct dd_function_table *driver)
+{
+    driver->GetString = get_string;
+    driver->UpdateState = update_state;
+    driver->GetBufferSize = NULL;
+    driver->Viewport = viewport;
+    driver->ChooseTextureFormat = swrastChooseTextureFormat;
+}
+
+static const char *es2_extensions[] = {
+   /* Used by mesa internally (cf all_mesa_extensions in ../common/utils.c) */
+   "GL_ARB_draw_buffers",
+   "GL_ARB_multisample",
+   "GL_ARB_texture_compression",
+   "GL_ARB_transpose_matrix",
+   "GL_ARB_vertex_buffer_object",
+   "GL_ARB_window_pos",
+   "GL_EXT_blend_func_separate",
+   "GL_EXT_compiled_vertex_array",
+   "GL_EXT_framebuffer_blit",
+   "GL_EXT_multi_draw_arrays",
+   "GL_EXT_polygon_offset",
+   "GL_EXT_texture_object",
+   "GL_EXT_vertex_array",
+   "GL_IBM_multimode_draw_arrays",
+   "GL_MESA_window_pos",
+   "GL_NV_vertex_program",
+
+   /* Required by GLES2 */
+   "GL_ARB_fragment_program",
+   "GL_ARB_fragment_shader",
+   "GL_ARB_multitexture",
+   "GL_ARB_shader_objects",
+   "GL_ARB_texture_cube_map",
+   "GL_ARB_texture_mirrored_repeat",
+   "GL_ARB_texture_non_power_of_two",
+   "GL_ARB_vertex_shader",
+   "GL_EXT_blend_color",
+   "GL_EXT_blend_equation_separate",
+   "GL_EXT_blend_minmax",
+   "GL_EXT_blend_subtract",
+   "GL_EXT_stencil_wrap",
+
+   /* Optional GLES2 */
+   "GL_ARB_framebuffer_object",
+   "GL_EXT_texture_filter_anisotropic",
+   "GL_ARB_depth_texture",
+   "GL_EXT_packed_depth_stencil",
+   "GL_EXT_framebuffer_object",
+   NULL,
+};
+
+static void
+InitExtensionsES2(struct gl_context *ctx)
+{
+   int i;
+
+   for (i = 0; es2_extensions[i]; i++)
+      _mesa_enable_extension(ctx, es2_extensions[i]);
+}
+
+/**
+ * Context-related functions.
+ */
+
+static GLboolean
+dri_create_context(gl_api api,
+		   const struct gl_config * visual,
+		   __DRIcontext * cPriv, void *sharedContextPrivate)
+{
+    struct dri_context *ctx = NULL;
+    struct dri_context *share = (struct dri_context *)sharedContextPrivate;
+    struct gl_context *mesaCtx = NULL;
+    struct gl_context *sharedCtx = NULL;
+    struct dd_function_table functions;
+
+    TRACE;
+
+    ctx = CALLOC_STRUCT(dri_context);
+    if (ctx == NULL)
+	goto context_fail;
+
+    cPriv->driverPrivate = ctx;
+    ctx->cPriv = cPriv;
+
+    /* build table of device driver functions */
+    _mesa_init_driver_functions(&functions);
+    swrast_init_driver_functions(&functions);
+
+    if (share) {
+	sharedCtx = &share->Base;
+    }
+
+    mesaCtx = &ctx->Base;
+
+    /* basic context setup */
+    if (!_mesa_initialize_context(mesaCtx, api, visual, sharedCtx, &functions, (void *) cPriv)) {
+	goto context_fail;
+    }
+
+    /* do bounds checking to prevent segfaults and server crashes! */
+    mesaCtx->Const.CheckArrayBounds = GL_TRUE;
+
+    /* create module contexts */
+    _swrast_CreateContext( mesaCtx );
+    _vbo_CreateContext( mesaCtx );
+    _tnl_CreateContext( mesaCtx );
+    _swsetup_CreateContext( mesaCtx );
+    _swsetup_Wakeup( mesaCtx );
+
+    /* use default TCL pipeline */
+    {
+       TNLcontext *tnl = TNL_CONTEXT(mesaCtx);
+       tnl->Driver.RunPipeline = _tnl_run_pipeline;
+    }
+
+    _mesa_meta_init(mesaCtx);
+    _mesa_enable_sw_extensions(mesaCtx);
+
+    switch (api) {
+    case API_OPENGL:
+        _mesa_enable_1_3_extensions(mesaCtx);
+        _mesa_enable_1_4_extensions(mesaCtx);
+        _mesa_enable_1_5_extensions(mesaCtx);
+        _mesa_enable_2_0_extensions(mesaCtx);
+        _mesa_enable_2_1_extensions(mesaCtx);
+        break;
+    case API_OPENGLES:
+        _mesa_enable_1_3_extensions(mesaCtx);
+        _mesa_enable_1_4_extensions(mesaCtx);
+        _mesa_enable_1_5_extensions(mesaCtx);
+
+        break;
+    case API_OPENGLES2:
+        InitExtensionsES2( mesaCtx);
+        break;
+    }
+
+    return GL_TRUE;
+
+context_fail:
+
+    FREE(ctx);
+
+    return GL_FALSE;
+}
+
+static void
+dri_destroy_context(__DRIcontext * cPriv)
+{
+    TRACE;
+
+    if (cPriv) {
+	struct dri_context *ctx = dri_context(cPriv);
+	struct gl_context *mesaCtx;
+
+	mesaCtx = &ctx->Base;
+
+        _mesa_meta_free(mesaCtx);
+	_swsetup_DestroyContext( mesaCtx );
+	_swrast_DestroyContext( mesaCtx );
+	_tnl_DestroyContext( mesaCtx );
+	_vbo_DestroyContext( mesaCtx );
+	_mesa_destroy_context( mesaCtx );
+    }
+}
+
+static GLboolean
+dri_make_current(__DRIcontext * cPriv,
+		 __DRIdrawable * driDrawPriv,
+		 __DRIdrawable * driReadPriv)
+{
+    struct gl_context *mesaCtx;
+    struct gl_framebuffer *mesaDraw;
+    struct gl_framebuffer *mesaRead;
+    TRACE;
+
+    if (cPriv) {
+	struct dri_context *ctx = dri_context(cPriv);
+	struct dri_drawable *draw;
+	struct dri_drawable *read;
+
+	if (!driDrawPriv || !driReadPriv)
+	    return GL_FALSE;
+
+	draw = dri_drawable(driDrawPriv);
+	read = dri_drawable(driReadPriv);
+	mesaCtx = &ctx->Base;
+	mesaDraw = &draw->Base;
+	mesaRead = &read->Base;
+
+	/* check for same context and buffer */
+	if (mesaCtx == _mesa_get_current_context()
+	    && mesaCtx->DrawBuffer == mesaDraw
+	    && mesaCtx->ReadBuffer == mesaRead) {
+	    return GL_TRUE;
+	}
+
+	_glapi_check_multithread();
+
+	swrast_check_and_update_window_size(mesaCtx, mesaDraw);
+	if (mesaRead != mesaDraw)
+	    swrast_check_and_update_window_size(mesaCtx, mesaRead);
+
+	_mesa_make_current( mesaCtx,
+			    mesaDraw,
+			    mesaRead );
+    }
+    else {
+	/* unbind */
+	_mesa_make_current( NULL, NULL, NULL );
+    }
+
+    return GL_TRUE;
+}
+
+static GLboolean
+dri_unbind_context(__DRIcontext * cPriv)
+{
+    TRACE;
+    (void) cPriv;
+
+    /* Unset current context and dispath table */
+    _mesa_make_current(NULL, NULL, NULL);
+
+    return GL_TRUE;
+}
+
+
+const struct __DriverAPIRec driDriverAPI = {
+    /*.InitScreen = */dri_init_screen,
+    /*.DestroyScreen = */dri_destroy_screen,
+    /*.CreateContext = */dri_create_context,
+    /*.DestroyContext = */dri_destroy_context,
+    /*.CreateBuffer = */dri_create_buffer,
+    /*.DestroyBuffer = */dri_destroy_buffer,
+    /*.SwapBuffers = */dri_swap_buffers,
+    /*.MakeCurrent = */dri_make_current,
+    /*.UnbindContext = */dri_unbind_context,
+};
+
+/* This is the table of extensions that the loader will dlsym() for. */
+PUBLIC const __DRIextension *__driDriverExtensions[] = {
+    &driCoreExtension.base,
+    &driSWRastExtension.base,
+    NULL
+};
diff --git a/mesalib/src/mesa/drivers/windows/gdi/mesa.def b/mesalib/src/mesa/drivers/windows/gdi/mesa.def
index fbf275609..d5c98801d 100644
--- a/mesalib/src/mesa/drivers/windows/gdi/mesa.def
+++ b/mesalib/src/mesa/drivers/windows/gdi/mesa.def
@@ -1,856 +1,856 @@
-; DO NOT EDIT - This file generated automatically by mesadef.py script

-;DESCRIPTION 'Mesa (OpenGL work-alike) for Win32'

-VERSION 6.5

-;

-; Module definition file for Mesa (OPENGL32.DLL)

-;

-; Note: The OpenGL functions use the STDCALL

-; function calling convention.  Microsoft's

-; OPENGL32 uses this convention and so must the

-; Mesa OPENGL32 so that the Mesa DLL can be used

-; as a drop-in replacement.

-;

-; The linker exports STDCALL entry points with

-; 'decorated' names; e.g., _glBegin@0, where the

-; trailing number is the number of bytes of 

-; parameter data pushed onto the stack.  The

-; callee is responsible for popping this data

-; off the stack, usually via a RETF n instruction.

-;

-; However, the Microsoft OPENGL32.DLL does not export

-; the decorated names, even though the calling convention

-; is STDCALL.  So, this module definition file is

-; needed to force the Mesa OPENGL32.DLL to export the

-; symbols in the same manner as the Microsoft DLL.

-; Were it not for this problem, this file would not

-; be needed (for the gl* functions) since the entry

-; points are compiled with dllexport declspec.

-;

-EXPORTS

-	glNewList

-	glEndList

-	glCallList

-	glCallLists

-	glDeleteLists

-	glGenLists

-	glListBase

-	glBegin

-	glBitmap

-	glColor3b

-	glColor3bv

-	glColor3d

-	glColor3dv

-	glColor3f

-	glColor3fv

-	glColor3i

-	glColor3iv

-	glColor3s

-	glColor3sv

-	glColor3ub

-	glColor3ubv

-	glColor3ui

-	glColor3uiv

-	glColor3us

-	glColor3usv

-	glColor4b

-	glColor4bv

-	glColor4d

-	glColor4dv

-	glColor4f

-	glColor4fv

-	glColor4i

-	glColor4iv

-	glColor4s

-	glColor4sv

-	glColor4ub

-	glColor4ubv

-	glColor4ui

-	glColor4uiv

-	glColor4us

-	glColor4usv

-	glEdgeFlag

-	glEdgeFlagv

-	glEnd

-	glIndexd

-	glIndexdv

-	glIndexf

-	glIndexfv

-	glIndexi

-	glIndexiv

-	glIndexs

-	glIndexsv

-	glNormal3b

-	glNormal3bv

-	glNormal3d

-	glNormal3dv

-	glNormal3f

-	glNormal3fv

-	glNormal3i

-	glNormal3iv

-	glNormal3s

-	glNormal3sv

-	glRasterPos2d

-	glRasterPos2dv

-	glRasterPos2f

-	glRasterPos2fv

-	glRasterPos2i

-	glRasterPos2iv

-	glRasterPos2s

-	glRasterPos2sv

-	glRasterPos3d

-	glRasterPos3dv

-	glRasterPos3f

-	glRasterPos3fv

-	glRasterPos3i

-	glRasterPos3iv

-	glRasterPos3s

-	glRasterPos3sv

-	glRasterPos4d

-	glRasterPos4dv

-	glRasterPos4f

-	glRasterPos4fv

-	glRasterPos4i

-	glRasterPos4iv

-	glRasterPos4s

-	glRasterPos4sv

-	glRectd

-	glRectdv

-	glRectf

-	glRectfv

-	glRecti

-	glRectiv

-	glRects

-	glRectsv

-	glTexCoord1d

-	glTexCoord1dv

-	glTexCoord1f

-	glTexCoord1fv

-	glTexCoord1i

-	glTexCoord1iv

-	glTexCoord1s

-	glTexCoord1sv

-	glTexCoord2d

-	glTexCoord2dv

-	glTexCoord2f

-	glTexCoord2fv

-	glTexCoord2i

-	glTexCoord2iv

-	glTexCoord2s

-	glTexCoord2sv

-	glTexCoord3d

-	glTexCoord3dv

-	glTexCoord3f

-	glTexCoord3fv

-	glTexCoord3i

-	glTexCoord3iv

-	glTexCoord3s

-	glTexCoord3sv

-	glTexCoord4d

-	glTexCoord4dv

-	glTexCoord4f

-	glTexCoord4fv

-	glTexCoord4i

-	glTexCoord4iv

-	glTexCoord4s

-	glTexCoord4sv

-	glVertex2d

-	glVertex2dv

-	glVertex2f

-	glVertex2fv

-	glVertex2i

-	glVertex2iv

-	glVertex2s

-	glVertex2sv

-	glVertex3d

-	glVertex3dv

-	glVertex3f

-	glVertex3fv

-	glVertex3i

-	glVertex3iv

-	glVertex3s

-	glVertex3sv

-	glVertex4d

-	glVertex4dv

-	glVertex4f

-	glVertex4fv

-	glVertex4i

-	glVertex4iv

-	glVertex4s

-	glVertex4sv

-	glClipPlane

-	glColorMaterial

-	glCullFace

-	glFogf

-	glFogfv

-	glFogi

-	glFogiv

-	glFrontFace

-	glHint

-	glLightf

-	glLightfv

-	glLighti

-	glLightiv

-	glLightModelf

-	glLightModelfv

-	glLightModeli

-	glLightModeliv

-	glLineStipple

-	glLineWidth

-	glMaterialf

-	glMaterialfv

-	glMateriali

-	glMaterialiv

-	glPointSize

-	glPolygonMode

-	glPolygonStipple

-	glScissor

-	glShadeModel

-	glTexParameterf

-	glTexParameterfv

-	glTexParameteri

-	glTexParameteriv

-	glTexImage1D

-	glTexImage2D

-	glTexEnvf

-	glTexEnvfv

-	glTexEnvi

-	glTexEnviv

-	glTexGend

-	glTexGendv

-	glTexGenf

-	glTexGenfv

-	glTexGeni

-	glTexGeniv

-	glFeedbackBuffer

-	glSelectBuffer

-	glRenderMode

-	glInitNames

-	glLoadName

-	glPassThrough

-	glPopName

-	glPushName

-	glDrawBuffer

-	glClear

-	glClearAccum

-	glClearIndex

-	glClearColor

-	glClearStencil

-	glClearDepth

-	glStencilMask

-	glColorMask

-	glDepthMask

-	glIndexMask

-	glAccum

-	glDisable

-	glEnable

-	glFinish

-	glFlush

-	glPopAttrib

-	glPushAttrib

-	glMap1d

-	glMap1f

-	glMap2d

-	glMap2f

-	glMapGrid1d

-	glMapGrid1f

-	glMapGrid2d

-	glMapGrid2f

-	glEvalCoord1d

-	glEvalCoord1dv

-	glEvalCoord1f

-	glEvalCoord1fv

-	glEvalCoord2d

-	glEvalCoord2dv

-	glEvalCoord2f

-	glEvalCoord2fv

-	glEvalMesh1

-	glEvalPoint1

-	glEvalMesh2

-	glEvalPoint2

-	glAlphaFunc

-	glBlendFunc

-	glLogicOp

-	glStencilFunc

-	glStencilOp

-	glDepthFunc

-	glPixelZoom

-	glPixelTransferf

-	glPixelTransferi

-	glPixelStoref

-	glPixelStorei

-	glPixelMapfv

-	glPixelMapuiv

-	glPixelMapusv

-	glReadBuffer

-	glCopyPixels

-	glReadPixels

-	glDrawPixels

-	glGetBooleanv

-	glGetClipPlane

-	glGetDoublev

-	glGetError

-	glGetFloatv

-	glGetIntegerv

-	glGetLightfv

-	glGetLightiv

-	glGetMapdv

-	glGetMapfv

-	glGetMapiv

-	glGetMaterialfv

-	glGetMaterialiv

-	glGetPixelMapfv

-	glGetPixelMapuiv

-	glGetPixelMapusv

-	glGetPolygonStipple

-	glGetString

-	glGetTexEnvfv

-	glGetTexEnviv

-	glGetTexGendv

-	glGetTexGenfv

-	glGetTexGeniv

-	glGetTexImage

-	glGetTexParameterfv

-	glGetTexParameteriv

-	glGetTexLevelParameterfv

-	glGetTexLevelParameteriv

-	glIsEnabled

-	glIsList

-	glDepthRange

-	glFrustum

-	glLoadIdentity

-	glLoadMatrixf

-	glLoadMatrixd

-	glMatrixMode

-	glMultMatrixf

-	glMultMatrixd

-	glOrtho

-	glPopMatrix

-	glPushMatrix

-	glRotated

-	glRotatef

-	glScaled

-	glScalef

-	glTranslated

-	glTranslatef

-	glViewport

-	glArrayElement

-	glColorPointer

-	glDisableClientState

-	glDrawArrays

-	glDrawElements

-	glEdgeFlagPointer

-	glEnableClientState

-	glGetPointerv

-	glIndexPointer

-	glInterleavedArrays

-	glNormalPointer

-	glTexCoordPointer

-	glVertexPointer

-	glPolygonOffset

-	glCopyTexImage1D

-	glCopyTexImage2D

-	glCopyTexSubImage1D

-	glCopyTexSubImage2D

-	glTexSubImage1D

-	glTexSubImage2D

-	glAreTexturesResident

-	glBindTexture

-	glDeleteTextures

-	glGenTextures

-	glIsTexture

-	glPrioritizeTextures

-	glIndexub

-	glIndexubv

-	glPopClientAttrib

-	glPushClientAttrib

-	glBlendColor

-	glBlendEquation

-	glDrawRangeElements

-	glColorTable

-	glColorTableParameterfv

-	glColorTableParameteriv

-	glCopyColorTable

-	glGetColorTable

-	glGetColorTableParameterfv

-	glGetColorTableParameteriv

-	glColorSubTable

-	glCopyColorSubTable

-	glConvolutionFilter1D

-	glConvolutionFilter2D

-	glConvolutionParameterf

-	glConvolutionParameterfv

-	glConvolutionParameteri

-	glConvolutionParameteriv

-	glCopyConvolutionFilter1D

-	glCopyConvolutionFilter2D

-	glGetConvolutionFilter

-	glGetConvolutionParameterfv

-	glGetConvolutionParameteriv

-	glGetSeparableFilter

-	glSeparableFilter2D

-	glGetHistogram

-	glGetHistogramParameterfv

-	glGetHistogramParameteriv

-	glGetMinmax

-	glGetMinmaxParameterfv

-	glGetMinmaxParameteriv

-	glHistogram

-	glMinmax

-	glResetHistogram

-	glResetMinmax

-	glTexImage3D

-	glTexSubImage3D

-	glCopyTexSubImage3D

-	glActiveTextureARB

-	glClientActiveTextureARB

-	glMultiTexCoord1dARB

-	glMultiTexCoord1dvARB

-	glMultiTexCoord1fARB

-	glMultiTexCoord1fvARB

-	glMultiTexCoord1iARB

-	glMultiTexCoord1ivARB

-	glMultiTexCoord1sARB

-	glMultiTexCoord1svARB

-	glMultiTexCoord2dARB

-	glMultiTexCoord2dvARB

-	glMultiTexCoord2fARB

-	glMultiTexCoord2fvARB

-	glMultiTexCoord2iARB

-	glMultiTexCoord2ivARB

-	glMultiTexCoord2sARB

-	glMultiTexCoord2svARB

-	glMultiTexCoord3dARB

-	glMultiTexCoord3dvARB

-	glMultiTexCoord3fARB

-	glMultiTexCoord3fvARB

-	glMultiTexCoord3iARB

-	glMultiTexCoord3ivARB

-	glMultiTexCoord3sARB

-	glMultiTexCoord3svARB

-	glMultiTexCoord4dARB

-	glMultiTexCoord4dvARB

-	glMultiTexCoord4fARB

-	glMultiTexCoord4fvARB

-	glMultiTexCoord4iARB

-	glMultiTexCoord4ivARB

-	glMultiTexCoord4sARB

-	glMultiTexCoord4svARB

-	glLoadTransposeMatrixfARB

-	glLoadTransposeMatrixdARB

-	glMultTransposeMatrixfARB

-	glMultTransposeMatrixdARB

-	glSampleCoverageARB

-	glCompressedTexImage3DARB

-	glCompressedTexImage2DARB

-	glCompressedTexImage1DARB

-	glCompressedTexSubImage3DARB

-	glCompressedTexSubImage2DARB

-	glCompressedTexSubImage1DARB

-	glGetCompressedTexImageARB

-	glActiveTexture

-	glClientActiveTexture

-	glMultiTexCoord1d

-	glMultiTexCoord1dv

-	glMultiTexCoord1f

-	glMultiTexCoord1fv

-	glMultiTexCoord1i

-	glMultiTexCoord1iv

-	glMultiTexCoord1s

-	glMultiTexCoord1sv

-	glMultiTexCoord2d

-	glMultiTexCoord2dv

-	glMultiTexCoord2f

-	glMultiTexCoord2fv

-	glMultiTexCoord2i

-	glMultiTexCoord2iv

-	glMultiTexCoord2s

-	glMultiTexCoord2sv

-	glMultiTexCoord3d

-	glMultiTexCoord3dv

-	glMultiTexCoord3f

-	glMultiTexCoord3fv

-	glMultiTexCoord3i

-	glMultiTexCoord3iv

-	glMultiTexCoord3s

-	glMultiTexCoord3sv

-	glMultiTexCoord4d

-	glMultiTexCoord4dv

-	glMultiTexCoord4f

-	glMultiTexCoord4fv

-	glMultiTexCoord4i

-	glMultiTexCoord4iv

-	glMultiTexCoord4s

-	glMultiTexCoord4sv

-	glLoadTransposeMatrixf

-	glLoadTransposeMatrixd

-	glMultTransposeMatrixf

-	glMultTransposeMatrixd

-	glSampleCoverage

-	glCompressedTexImage3D

-	glCompressedTexImage2D

-	glCompressedTexImage1D

-	glCompressedTexSubImage3D

-	glCompressedTexSubImage2D

-	glCompressedTexSubImage1D

-	glGetCompressedTexImage

-	glBlendColorEXT

-	glPolygonOffsetEXT

-	glTexImage3DEXT

-	glTexSubImage3DEXT

-	glTexSubImage1DEXT

-	glTexSubImage2DEXT

-	glCopyTexImage1DEXT

-	glCopyTexImage2DEXT

-	glCopyTexSubImage1DEXT

-	glCopyTexSubImage2DEXT

-	glCopyTexSubImage3DEXT

-	glAreTexturesResidentEXT

-	glBindTextureEXT

-	glDeleteTexturesEXT

-	glGenTexturesEXT

-	glIsTextureEXT

-	glPrioritizeTexturesEXT

-	glArrayElementEXT

-	glColorPointerEXT

-	glDrawArraysEXT

-	glEdgeFlagPointerEXT

-	glGetPointervEXT

-	glIndexPointerEXT

-	glNormalPointerEXT

-	glTexCoordPointerEXT

-	glVertexPointerEXT

-	glBlendEquationEXT

-	glPointParameterfEXT

-	glPointParameterfvEXT

-	glPointParameterfARB

-	glPointParameterfvARB

-	glColorTableEXT

-	glGetColorTableEXT

-	glGetColorTableParameterivEXT

-	glGetColorTableParameterfvEXT

-	glLockArraysEXT

-	glUnlockArraysEXT

-	glDrawRangeElementsEXT

-	glSecondaryColor3bEXT

-	glSecondaryColor3bvEXT

-	glSecondaryColor3dEXT

-	glSecondaryColor3dvEXT

-	glSecondaryColor3fEXT

-	glSecondaryColor3fvEXT

-	glSecondaryColor3iEXT

-	glSecondaryColor3ivEXT

-	glSecondaryColor3sEXT

-	glSecondaryColor3svEXT

-	glSecondaryColor3ubEXT

-	glSecondaryColor3ubvEXT

-	glSecondaryColor3uiEXT

-	glSecondaryColor3uivEXT

-	glSecondaryColor3usEXT

-	glSecondaryColor3usvEXT

-	glSecondaryColorPointerEXT

-	glMultiDrawArraysEXT

-	glMultiDrawElementsEXT

-	glFogCoordfEXT

-	glFogCoordfvEXT

-	glFogCoorddEXT

-	glFogCoorddvEXT

-	glFogCoordPointerEXT

-	glBlendFuncSeparateEXT

-	glFlushVertexArrayRangeNV

-	glVertexArrayRangeNV

-	glCombinerParameterfvNV

-	glCombinerParameterfNV

-	glCombinerParameterivNV

-	glCombinerParameteriNV

-	glCombinerInputNV

-	glCombinerOutputNV

-	glFinalCombinerInputNV

-	glGetCombinerInputParameterfvNV

-	glGetCombinerInputParameterivNV

-	glGetCombinerOutputParameterfvNV

-	glGetCombinerOutputParameterivNV

-	glGetFinalCombinerInputParameterfvNV

-	glGetFinalCombinerInputParameterivNV

-	glResizeBuffersMESA

-	glWindowPos2dMESA

-	glWindowPos2dvMESA

-	glWindowPos2fMESA

-	glWindowPos2fvMESA

-	glWindowPos2iMESA

-	glWindowPos2ivMESA

-	glWindowPos2sMESA

-	glWindowPos2svMESA

-	glWindowPos3dMESA

-	glWindowPos3dvMESA

-	glWindowPos3fMESA

-	glWindowPos3fvMESA

-	glWindowPos3iMESA

-	glWindowPos3ivMESA

-	glWindowPos3sMESA

-	glWindowPos3svMESA

-	glWindowPos4dMESA

-	glWindowPos4dvMESA

-	glWindowPos4fMESA

-	glWindowPos4fvMESA

-	glWindowPos4iMESA

-	glWindowPos4ivMESA

-	glWindowPos4sMESA

-	glWindowPos4svMESA

-	glWindowPos2dARB

-	glWindowPos2fARB

-	glWindowPos2iARB

-	glWindowPos2sARB

-	glWindowPos2dvARB

-	glWindowPos2fvARB

-	glWindowPos2ivARB

-	glWindowPos2svARB

-	glWindowPos3dARB

-	glWindowPos3fARB

-	glWindowPos3iARB

-	glWindowPos3sARB

-	glWindowPos3dvARB

-	glWindowPos3fvARB

-	glWindowPos3ivARB

-	glWindowPos3svARB

-	glAreProgramsResidentNV

-	glBindProgramNV

-	glDeleteProgramsNV

-	glExecuteProgramNV

-	glGenProgramsNV

-	glGetProgramParameterdvNV

-	glGetProgramParameterfvNV

-	glGetProgramivNV

-	glGetProgramStringNV

-	glGetTrackMatrixivNV

-	glGetVertexAttribdvNV

-	glGetVertexAttribfvNV

-	glGetVertexAttribivNV

-	glGetVertexAttribPointervNV

-	glIsProgramNV

-	glLoadProgramNV

-	glProgramParameter4dNV

-	glProgramParameter4dvNV

-	glProgramParameter4fNV

-	glProgramParameter4fvNV

-	glProgramParameters4dvNV

-	glProgramParameters4fvNV

-	glRequestResidentProgramsNV

-	glTrackMatrixNV

-	glVertexAttribPointerNV

-	glVertexAttrib1dNV

-	glVertexAttrib1dvNV

-	glVertexAttrib1fNV

-	glVertexAttrib1fvNV

-	glVertexAttrib1sNV

-	glVertexAttrib1svNV

-	glVertexAttrib2dNV

-	glVertexAttrib2dvNV

-	glVertexAttrib2fNV

-	glVertexAttrib2fvNV

-	glVertexAttrib2sNV

-	glVertexAttrib2svNV

-	glVertexAttrib3dNV

-	glVertexAttrib3dvNV

-	glVertexAttrib3fNV

-	glVertexAttrib3fvNV

-	glVertexAttrib3sNV

-	glVertexAttrib3svNV

-	glVertexAttrib4dNV

-	glVertexAttrib4dvNV

-	glVertexAttrib4fNV

-	glVertexAttrib4fvNV

-	glVertexAttrib4sNV

-	glVertexAttrib4svNV

-	glVertexAttrib4ubNV

-	glVertexAttrib4ubvNV

-	glVertexAttribs1dvNV

-	glVertexAttribs1fvNV

-	glVertexAttribs1svNV

-	glVertexAttribs2dvNV

-	glVertexAttribs2fvNV

-	glVertexAttribs2svNV

-	glVertexAttribs3dvNV

-	glVertexAttribs3fvNV

-	glVertexAttribs3svNV

-	glVertexAttribs4dvNV

-	glVertexAttribs4fvNV

-	glVertexAttribs4svNV

-	glVertexAttribs4ubvNV

-	glPointParameteriNV

-	glPointParameterivNV

-	glFogCoordf

-	glFogCoordfv

-	glFogCoordd

-	glFogCoorddv

-	glFogCoordPointer

-	glMultiDrawArrays

-	glMultiDrawElements

-	glPointParameterf

-	glPointParameterfv

-	glPointParameteri

-	glPointParameteriv

-	glSecondaryColor3b

-	glSecondaryColor3bv

-	glSecondaryColor3d

-	glSecondaryColor3dv

-	glSecondaryColor3f

-	glSecondaryColor3fv

-	glSecondaryColor3i

-	glSecondaryColor3iv

-	glSecondaryColor3s

-	glSecondaryColor3sv

-	glSecondaryColor3ub

-	glSecondaryColor3ubv

-	glSecondaryColor3ui

-	glSecondaryColor3uiv

-	glSecondaryColor3us

-	glSecondaryColor3usv

-	glSecondaryColorPointer

-	glWindowPos2d

-	glWindowPos2dv

-	glWindowPos2f

-	glWindowPos2fv

-	glWindowPos2i

-	glWindowPos2iv

-	glWindowPos2s

-	glWindowPos2sv

-	glWindowPos3d

-	glWindowPos3dv

-	glWindowPos3f

-	glWindowPos3fv

-	glWindowPos3i

-	glWindowPos3iv

-	glWindowPos3s

-	glWindowPos3sv

-	glVertexAttrib1sARB

-	glVertexAttrib1fARB

-	glVertexAttrib1dARB

-	glVertexAttrib2sARB

-	glVertexAttrib2fARB

-	glVertexAttrib2dARB

-	glVertexAttrib3sARB

-	glVertexAttrib3fARB

-	glVertexAttrib3dARB

-	glVertexAttrib4sARB

-	glVertexAttrib4fARB

-	glVertexAttrib4dARB

-	glVertexAttrib4NubARB

-	glVertexAttrib1svARB

-	glVertexAttrib1fvARB

-	glVertexAttrib1dvARB

-	glVertexAttrib2svARB

-	glVertexAttrib2fvARB

-	glVertexAttrib2dvARB

-	glVertexAttrib3svARB

-	glVertexAttrib3fvARB

-	glVertexAttrib3dvARB

-	glVertexAttrib4bvARB

-	glVertexAttrib4svARB

-	glVertexAttrib4ivARB

-	glVertexAttrib4ubvARB

-	glVertexAttrib4usvARB

-	glVertexAttrib4uivARB

-	glVertexAttrib4fvARB

-	glVertexAttrib4dvARB

-	glVertexAttrib4NbvARB

-	glVertexAttrib4NsvARB

-	glVertexAttrib4NivARB

-	glVertexAttrib4NubvARB

-	glVertexAttrib4NusvARB

-	glVertexAttrib4NuivARB

-	glVertexAttribPointerARB

-	glEnableVertexAttribArrayARB

-	glDisableVertexAttribArrayARB

-	glProgramStringARB

-	glBindProgramARB

-	glDeleteProgramsARB

-	glGenProgramsARB

-	glIsProgramARB

-	glProgramEnvParameter4dARB

-	glProgramEnvParameter4dvARB

-	glProgramEnvParameter4fARB

-	glProgramEnvParameter4fvARB

-	glProgramLocalParameter4dARB

-	glProgramLocalParameter4dvARB

-	glProgramLocalParameter4fARB

-	glProgramLocalParameter4fvARB

-	glGetProgramEnvParameterdvARB

-	glGetProgramEnvParameterfvARB

-	glGetProgramLocalParameterdvARB

-	glGetProgramLocalParameterfvARB

-	glGetProgramivARB

-	glGetProgramStringARB

-	glGetVertexAttribdvARB

-	glGetVertexAttribfvARB

-	glGetVertexAttribivARB

-	glGetVertexAttribPointervARB

-	glProgramNamedParameter4fNV

-	glProgramNamedParameter4dNV

-	glProgramNamedParameter4fvNV

-	glProgramNamedParameter4dvNV

-	glGetProgramNamedParameterfvNV

-	glGetProgramNamedParameterdvNV

-	glBindBufferARB

-	glBufferDataARB

-	glBufferSubDataARB

-	glDeleteBuffersARB

-	glGenBuffersARB

-	glGetBufferParameterivARB

-	glGetBufferPointervARB

-	glGetBufferSubDataARB

-	glIsBufferARB

-	glMapBufferARB

-	glUnmapBufferARB

-	glGenQueriesARB

-	glDeleteQueriesARB

-	glIsQueryARB

-	glBeginQueryARB

-	glEndQueryARB

-	glGetQueryivARB

-	glGetQueryObjectivARB

-	glGetQueryObjectuivARB

-	glBindBuffer

-	glBufferData

-	glBufferSubData

-	glDeleteBuffers

-	glGenBuffers

-	glGetBufferParameteriv

-	glGetBufferPointerv

-	glGetBufferSubData

-	glIsBuffer

-	glMapBuffer

-	glUnmapBuffer

-	glGenQueries

-	glDeleteQueries

-	glIsQuery

-	glBeginQuery

-	glEndQuery

-	glGetQueryiv

-	glGetQueryObjectiv

-	glGetQueryObjectuiv

-;

-; WGL API

-	wglChoosePixelFormat

-	wglCopyContext

-	wglCreateContext

-	wglCreateLayerContext

-	wglDeleteContext

-	wglDescribeLayerPlane

-	wglDescribePixelFormat

-	wglGetCurrentContext

-	wglGetCurrentDC

-	wglGetLayerPaletteEntries

-	wglGetPixelFormat

-	wglGetProcAddress

-	wglMakeCurrent

-	wglRealizeLayerPalette

-	wglSetLayerPaletteEntries

-	wglSetPixelFormat

-	wglShareLists

-	wglSwapBuffers

-	wglSwapLayerBuffers

-	wglUseFontBitmapsA

-	wglUseFontBitmapsW

-	wglUseFontOutlinesA

-	wglUseFontOutlinesW

-	wglGetExtensionsStringARB

+; DO NOT EDIT - This file generated automatically by mesadef.py script
+;DESCRIPTION 'Mesa (OpenGL work-alike) for Win32'
+VERSION 6.5
+;
+; Module definition file for Mesa (OPENGL32.DLL)
+;
+; Note: The OpenGL functions use the STDCALL
+; function calling convention.  Microsoft's
+; OPENGL32 uses this convention and so must the
+; Mesa OPENGL32 so that the Mesa DLL can be used
+; as a drop-in replacement.
+;
+; The linker exports STDCALL entry points with
+; 'decorated' names; e.g., _glBegin@0, where the
+; trailing number is the number of bytes of 
+; parameter data pushed onto the stack.  The
+; callee is responsible for popping this data
+; off the stack, usually via a RETF n instruction.
+;
+; However, the Microsoft OPENGL32.DLL does not export
+; the decorated names, even though the calling convention
+; is STDCALL.  So, this module definition file is
+; needed to force the Mesa OPENGL32.DLL to export the
+; symbols in the same manner as the Microsoft DLL.
+; Were it not for this problem, this file would not
+; be needed (for the gl* functions) since the entry
+; points are compiled with dllexport declspec.
+;
+EXPORTS
+	glNewList
+	glEndList
+	glCallList
+	glCallLists
+	glDeleteLists
+	glGenLists
+	glListBase
+	glBegin
+	glBitmap
+	glColor3b
+	glColor3bv
+	glColor3d
+	glColor3dv
+	glColor3f
+	glColor3fv
+	glColor3i
+	glColor3iv
+	glColor3s
+	glColor3sv
+	glColor3ub
+	glColor3ubv
+	glColor3ui
+	glColor3uiv
+	glColor3us
+	glColor3usv
+	glColor4b
+	glColor4bv
+	glColor4d
+	glColor4dv
+	glColor4f
+	glColor4fv
+	glColor4i
+	glColor4iv
+	glColor4s
+	glColor4sv
+	glColor4ub
+	glColor4ubv
+	glColor4ui
+	glColor4uiv
+	glColor4us
+	glColor4usv
+	glEdgeFlag
+	glEdgeFlagv
+	glEnd
+	glIndexd
+	glIndexdv
+	glIndexf
+	glIndexfv
+	glIndexi
+	glIndexiv
+	glIndexs
+	glIndexsv
+	glNormal3b
+	glNormal3bv
+	glNormal3d
+	glNormal3dv
+	glNormal3f
+	glNormal3fv
+	glNormal3i
+	glNormal3iv
+	glNormal3s
+	glNormal3sv
+	glRasterPos2d
+	glRasterPos2dv
+	glRasterPos2f
+	glRasterPos2fv
+	glRasterPos2i
+	glRasterPos2iv
+	glRasterPos2s
+	glRasterPos2sv
+	glRasterPos3d
+	glRasterPos3dv
+	glRasterPos3f
+	glRasterPos3fv
+	glRasterPos3i
+	glRasterPos3iv
+	glRasterPos3s
+	glRasterPos3sv
+	glRasterPos4d
+	glRasterPos4dv
+	glRasterPos4f
+	glRasterPos4fv
+	glRasterPos4i
+	glRasterPos4iv
+	glRasterPos4s
+	glRasterPos4sv
+	glRectd
+	glRectdv
+	glRectf
+	glRectfv
+	glRecti
+	glRectiv
+	glRects
+	glRectsv
+	glTexCoord1d
+	glTexCoord1dv
+	glTexCoord1f
+	glTexCoord1fv
+	glTexCoord1i
+	glTexCoord1iv
+	glTexCoord1s
+	glTexCoord1sv
+	glTexCoord2d
+	glTexCoord2dv
+	glTexCoord2f
+	glTexCoord2fv
+	glTexCoord2i
+	glTexCoord2iv
+	glTexCoord2s
+	glTexCoord2sv
+	glTexCoord3d
+	glTexCoord3dv
+	glTexCoord3f
+	glTexCoord3fv
+	glTexCoord3i
+	glTexCoord3iv
+	glTexCoord3s
+	glTexCoord3sv
+	glTexCoord4d
+	glTexCoord4dv
+	glTexCoord4f
+	glTexCoord4fv
+	glTexCoord4i
+	glTexCoord4iv
+	glTexCoord4s
+	glTexCoord4sv
+	glVertex2d
+	glVertex2dv
+	glVertex2f
+	glVertex2fv
+	glVertex2i
+	glVertex2iv
+	glVertex2s
+	glVertex2sv
+	glVertex3d
+	glVertex3dv
+	glVertex3f
+	glVertex3fv
+	glVertex3i
+	glVertex3iv
+	glVertex3s
+	glVertex3sv
+	glVertex4d
+	glVertex4dv
+	glVertex4f
+	glVertex4fv
+	glVertex4i
+	glVertex4iv
+	glVertex4s
+	glVertex4sv
+	glClipPlane
+	glColorMaterial
+	glCullFace
+	glFogf
+	glFogfv
+	glFogi
+	glFogiv
+	glFrontFace
+	glHint
+	glLightf
+	glLightfv
+	glLighti
+	glLightiv
+	glLightModelf
+	glLightModelfv
+	glLightModeli
+	glLightModeliv
+	glLineStipple
+	glLineWidth
+	glMaterialf
+	glMaterialfv
+	glMateriali
+	glMaterialiv
+	glPointSize
+	glPolygonMode
+	glPolygonStipple
+	glScissor
+	glShadeModel
+	glTexParameterf
+	glTexParameterfv
+	glTexParameteri
+	glTexParameteriv
+	glTexImage1D
+	glTexImage2D
+	glTexEnvf
+	glTexEnvfv
+	glTexEnvi
+	glTexEnviv
+	glTexGend
+	glTexGendv
+	glTexGenf
+	glTexGenfv
+	glTexGeni
+	glTexGeniv
+	glFeedbackBuffer
+	glSelectBuffer
+	glRenderMode
+	glInitNames
+	glLoadName
+	glPassThrough
+	glPopName
+	glPushName
+	glDrawBuffer
+	glClear
+	glClearAccum
+	glClearIndex
+	glClearColor
+	glClearStencil
+	glClearDepth
+	glStencilMask
+	glColorMask
+	glDepthMask
+	glIndexMask
+	glAccum
+	glDisable
+	glEnable
+	glFinish
+	glFlush
+	glPopAttrib
+	glPushAttrib
+	glMap1d
+	glMap1f
+	glMap2d
+	glMap2f
+	glMapGrid1d
+	glMapGrid1f
+	glMapGrid2d
+	glMapGrid2f
+	glEvalCoord1d
+	glEvalCoord1dv
+	glEvalCoord1f
+	glEvalCoord1fv
+	glEvalCoord2d
+	glEvalCoord2dv
+	glEvalCoord2f
+	glEvalCoord2fv
+	glEvalMesh1
+	glEvalPoint1
+	glEvalMesh2
+	glEvalPoint2
+	glAlphaFunc
+	glBlendFunc
+	glLogicOp
+	glStencilFunc
+	glStencilOp
+	glDepthFunc
+	glPixelZoom
+	glPixelTransferf
+	glPixelTransferi
+	glPixelStoref
+	glPixelStorei
+	glPixelMapfv
+	glPixelMapuiv
+	glPixelMapusv
+	glReadBuffer
+	glCopyPixels
+	glReadPixels
+	glDrawPixels
+	glGetBooleanv
+	glGetClipPlane
+	glGetDoublev
+	glGetError
+	glGetFloatv
+	glGetIntegerv
+	glGetLightfv
+	glGetLightiv
+	glGetMapdv
+	glGetMapfv
+	glGetMapiv
+	glGetMaterialfv
+	glGetMaterialiv
+	glGetPixelMapfv
+	glGetPixelMapuiv
+	glGetPixelMapusv
+	glGetPolygonStipple
+	glGetString
+	glGetTexEnvfv
+	glGetTexEnviv
+	glGetTexGendv
+	glGetTexGenfv
+	glGetTexGeniv
+	glGetTexImage
+	glGetTexParameterfv
+	glGetTexParameteriv
+	glGetTexLevelParameterfv
+	glGetTexLevelParameteriv
+	glIsEnabled
+	glIsList
+	glDepthRange
+	glFrustum
+	glLoadIdentity
+	glLoadMatrixf
+	glLoadMatrixd
+	glMatrixMode
+	glMultMatrixf
+	glMultMatrixd
+	glOrtho
+	glPopMatrix
+	glPushMatrix
+	glRotated
+	glRotatef
+	glScaled
+	glScalef
+	glTranslated
+	glTranslatef
+	glViewport
+	glArrayElement
+	glColorPointer
+	glDisableClientState
+	glDrawArrays
+	glDrawElements
+	glEdgeFlagPointer
+	glEnableClientState
+	glGetPointerv
+	glIndexPointer
+	glInterleavedArrays
+	glNormalPointer
+	glTexCoordPointer
+	glVertexPointer
+	glPolygonOffset
+	glCopyTexImage1D
+	glCopyTexImage2D
+	glCopyTexSubImage1D
+	glCopyTexSubImage2D
+	glTexSubImage1D
+	glTexSubImage2D
+	glAreTexturesResident
+	glBindTexture
+	glDeleteTextures
+	glGenTextures
+	glIsTexture
+	glPrioritizeTextures
+	glIndexub
+	glIndexubv
+	glPopClientAttrib
+	glPushClientAttrib
+	glBlendColor
+	glBlendEquation
+	glDrawRangeElements
+	glColorTable
+	glColorTableParameterfv
+	glColorTableParameteriv
+	glCopyColorTable
+	glGetColorTable
+	glGetColorTableParameterfv
+	glGetColorTableParameteriv
+	glColorSubTable
+	glCopyColorSubTable
+	glConvolutionFilter1D
+	glConvolutionFilter2D
+	glConvolutionParameterf
+	glConvolutionParameterfv
+	glConvolutionParameteri
+	glConvolutionParameteriv
+	glCopyConvolutionFilter1D
+	glCopyConvolutionFilter2D
+	glGetConvolutionFilter
+	glGetConvolutionParameterfv
+	glGetConvolutionParameteriv
+	glGetSeparableFilter
+	glSeparableFilter2D
+	glGetHistogram
+	glGetHistogramParameterfv
+	glGetHistogramParameteriv
+	glGetMinmax
+	glGetMinmaxParameterfv
+	glGetMinmaxParameteriv
+	glHistogram
+	glMinmax
+	glResetHistogram
+	glResetMinmax
+	glTexImage3D
+	glTexSubImage3D
+	glCopyTexSubImage3D
+	glActiveTextureARB
+	glClientActiveTextureARB
+	glMultiTexCoord1dARB
+	glMultiTexCoord1dvARB
+	glMultiTexCoord1fARB
+	glMultiTexCoord1fvARB
+	glMultiTexCoord1iARB
+	glMultiTexCoord1ivARB
+	glMultiTexCoord1sARB
+	glMultiTexCoord1svARB
+	glMultiTexCoord2dARB
+	glMultiTexCoord2dvARB
+	glMultiTexCoord2fARB
+	glMultiTexCoord2fvARB
+	glMultiTexCoord2iARB
+	glMultiTexCoord2ivARB
+	glMultiTexCoord2sARB
+	glMultiTexCoord2svARB
+	glMultiTexCoord3dARB
+	glMultiTexCoord3dvARB
+	glMultiTexCoord3fARB
+	glMultiTexCoord3fvARB
+	glMultiTexCoord3iARB
+	glMultiTexCoord3ivARB
+	glMultiTexCoord3sARB
+	glMultiTexCoord3svARB
+	glMultiTexCoord4dARB
+	glMultiTexCoord4dvARB
+	glMultiTexCoord4fARB
+	glMultiTexCoord4fvARB
+	glMultiTexCoord4iARB
+	glMultiTexCoord4ivARB
+	glMultiTexCoord4sARB
+	glMultiTexCoord4svARB
+	glLoadTransposeMatrixfARB
+	glLoadTransposeMatrixdARB
+	glMultTransposeMatrixfARB
+	glMultTransposeMatrixdARB
+	glSampleCoverageARB
+	glCompressedTexImage3DARB
+	glCompressedTexImage2DARB
+	glCompressedTexImage1DARB
+	glCompressedTexSubImage3DARB
+	glCompressedTexSubImage2DARB
+	glCompressedTexSubImage1DARB
+	glGetCompressedTexImageARB
+	glActiveTexture
+	glClientActiveTexture
+	glMultiTexCoord1d
+	glMultiTexCoord1dv
+	glMultiTexCoord1f
+	glMultiTexCoord1fv
+	glMultiTexCoord1i
+	glMultiTexCoord1iv
+	glMultiTexCoord1s
+	glMultiTexCoord1sv
+	glMultiTexCoord2d
+	glMultiTexCoord2dv
+	glMultiTexCoord2f
+	glMultiTexCoord2fv
+	glMultiTexCoord2i
+	glMultiTexCoord2iv
+	glMultiTexCoord2s
+	glMultiTexCoord2sv
+	glMultiTexCoord3d
+	glMultiTexCoord3dv
+	glMultiTexCoord3f
+	glMultiTexCoord3fv
+	glMultiTexCoord3i
+	glMultiTexCoord3iv
+	glMultiTexCoord3s
+	glMultiTexCoord3sv
+	glMultiTexCoord4d
+	glMultiTexCoord4dv
+	glMultiTexCoord4f
+	glMultiTexCoord4fv
+	glMultiTexCoord4i
+	glMultiTexCoord4iv
+	glMultiTexCoord4s
+	glMultiTexCoord4sv
+	glLoadTransposeMatrixf
+	glLoadTransposeMatrixd
+	glMultTransposeMatrixf
+	glMultTransposeMatrixd
+	glSampleCoverage
+	glCompressedTexImage3D
+	glCompressedTexImage2D
+	glCompressedTexImage1D
+	glCompressedTexSubImage3D
+	glCompressedTexSubImage2D
+	glCompressedTexSubImage1D
+	glGetCompressedTexImage
+	glBlendColorEXT
+	glPolygonOffsetEXT
+	glTexImage3DEXT
+	glTexSubImage3DEXT
+	glTexSubImage1DEXT
+	glTexSubImage2DEXT
+	glCopyTexImage1DEXT
+	glCopyTexImage2DEXT
+	glCopyTexSubImage1DEXT
+	glCopyTexSubImage2DEXT
+	glCopyTexSubImage3DEXT
+	glAreTexturesResidentEXT
+	glBindTextureEXT
+	glDeleteTexturesEXT
+	glGenTexturesEXT
+	glIsTextureEXT
+	glPrioritizeTexturesEXT
+	glArrayElementEXT
+	glColorPointerEXT
+	glDrawArraysEXT
+	glEdgeFlagPointerEXT
+	glGetPointervEXT
+	glIndexPointerEXT
+	glNormalPointerEXT
+	glTexCoordPointerEXT
+	glVertexPointerEXT
+	glBlendEquationEXT
+	glPointParameterfEXT
+	glPointParameterfvEXT
+	glPointParameterfARB
+	glPointParameterfvARB
+	glColorTableEXT
+	glGetColorTableEXT
+	glGetColorTableParameterivEXT
+	glGetColorTableParameterfvEXT
+	glLockArraysEXT
+	glUnlockArraysEXT
+	glDrawRangeElementsEXT
+	glSecondaryColor3bEXT
+	glSecondaryColor3bvEXT
+	glSecondaryColor3dEXT
+	glSecondaryColor3dvEXT
+	glSecondaryColor3fEXT
+	glSecondaryColor3fvEXT
+	glSecondaryColor3iEXT
+	glSecondaryColor3ivEXT
+	glSecondaryColor3sEXT
+	glSecondaryColor3svEXT
+	glSecondaryColor3ubEXT
+	glSecondaryColor3ubvEXT
+	glSecondaryColor3uiEXT
+	glSecondaryColor3uivEXT
+	glSecondaryColor3usEXT
+	glSecondaryColor3usvEXT
+	glSecondaryColorPointerEXT
+	glMultiDrawArraysEXT
+	glMultiDrawElementsEXT
+	glFogCoordfEXT
+	glFogCoordfvEXT
+	glFogCoorddEXT
+	glFogCoorddvEXT
+	glFogCoordPointerEXT
+	glBlendFuncSeparateEXT
+	glFlushVertexArrayRangeNV
+	glVertexArrayRangeNV
+	glCombinerParameterfvNV
+	glCombinerParameterfNV
+	glCombinerParameterivNV
+	glCombinerParameteriNV
+	glCombinerInputNV
+	glCombinerOutputNV
+	glFinalCombinerInputNV
+	glGetCombinerInputParameterfvNV
+	glGetCombinerInputParameterivNV
+	glGetCombinerOutputParameterfvNV
+	glGetCombinerOutputParameterivNV
+	glGetFinalCombinerInputParameterfvNV
+	glGetFinalCombinerInputParameterivNV
+	glResizeBuffersMESA
+	glWindowPos2dMESA
+	glWindowPos2dvMESA
+	glWindowPos2fMESA
+	glWindowPos2fvMESA
+	glWindowPos2iMESA
+	glWindowPos2ivMESA
+	glWindowPos2sMESA
+	glWindowPos2svMESA
+	glWindowPos3dMESA
+	glWindowPos3dvMESA
+	glWindowPos3fMESA
+	glWindowPos3fvMESA
+	glWindowPos3iMESA
+	glWindowPos3ivMESA
+	glWindowPos3sMESA
+	glWindowPos3svMESA
+	glWindowPos4dMESA
+	glWindowPos4dvMESA
+	glWindowPos4fMESA
+	glWindowPos4fvMESA
+	glWindowPos4iMESA
+	glWindowPos4ivMESA
+	glWindowPos4sMESA
+	glWindowPos4svMESA
+	glWindowPos2dARB
+	glWindowPos2fARB
+	glWindowPos2iARB
+	glWindowPos2sARB
+	glWindowPos2dvARB
+	glWindowPos2fvARB
+	glWindowPos2ivARB
+	glWindowPos2svARB
+	glWindowPos3dARB
+	glWindowPos3fARB
+	glWindowPos3iARB
+	glWindowPos3sARB
+	glWindowPos3dvARB
+	glWindowPos3fvARB
+	glWindowPos3ivARB
+	glWindowPos3svARB
+	glAreProgramsResidentNV
+	glBindProgramNV
+	glDeleteProgramsNV
+	glExecuteProgramNV
+	glGenProgramsNV
+	glGetProgramParameterdvNV
+	glGetProgramParameterfvNV
+	glGetProgramivNV
+	glGetProgramStringNV
+	glGetTrackMatrixivNV
+	glGetVertexAttribdvNV
+	glGetVertexAttribfvNV
+	glGetVertexAttribivNV
+	glGetVertexAttribPointervNV
+	glIsProgramNV
+	glLoadProgramNV
+	glProgramParameter4dNV
+	glProgramParameter4dvNV
+	glProgramParameter4fNV
+	glProgramParameter4fvNV
+	glProgramParameters4dvNV
+	glProgramParameters4fvNV
+	glRequestResidentProgramsNV
+	glTrackMatrixNV
+	glVertexAttribPointerNV
+	glVertexAttrib1dNV
+	glVertexAttrib1dvNV
+	glVertexAttrib1fNV
+	glVertexAttrib1fvNV
+	glVertexAttrib1sNV
+	glVertexAttrib1svNV
+	glVertexAttrib2dNV
+	glVertexAttrib2dvNV
+	glVertexAttrib2fNV
+	glVertexAttrib2fvNV
+	glVertexAttrib2sNV
+	glVertexAttrib2svNV
+	glVertexAttrib3dNV
+	glVertexAttrib3dvNV
+	glVertexAttrib3fNV
+	glVertexAttrib3fvNV
+	glVertexAttrib3sNV
+	glVertexAttrib3svNV
+	glVertexAttrib4dNV
+	glVertexAttrib4dvNV
+	glVertexAttrib4fNV
+	glVertexAttrib4fvNV
+	glVertexAttrib4sNV
+	glVertexAttrib4svNV
+	glVertexAttrib4ubNV
+	glVertexAttrib4ubvNV
+	glVertexAttribs1dvNV
+	glVertexAttribs1fvNV
+	glVertexAttribs1svNV
+	glVertexAttribs2dvNV
+	glVertexAttribs2fvNV
+	glVertexAttribs2svNV
+	glVertexAttribs3dvNV
+	glVertexAttribs3fvNV
+	glVertexAttribs3svNV
+	glVertexAttribs4dvNV
+	glVertexAttribs4fvNV
+	glVertexAttribs4svNV
+	glVertexAttribs4ubvNV
+	glPointParameteriNV
+	glPointParameterivNV
+	glFogCoordf
+	glFogCoordfv
+	glFogCoordd
+	glFogCoorddv
+	glFogCoordPointer
+	glMultiDrawArrays
+	glMultiDrawElements
+	glPointParameterf
+	glPointParameterfv
+	glPointParameteri
+	glPointParameteriv
+	glSecondaryColor3b
+	glSecondaryColor3bv
+	glSecondaryColor3d
+	glSecondaryColor3dv
+	glSecondaryColor3f
+	glSecondaryColor3fv
+	glSecondaryColor3i
+	glSecondaryColor3iv
+	glSecondaryColor3s
+	glSecondaryColor3sv
+	glSecondaryColor3ub
+	glSecondaryColor3ubv
+	glSecondaryColor3ui
+	glSecondaryColor3uiv
+	glSecondaryColor3us
+	glSecondaryColor3usv
+	glSecondaryColorPointer
+	glWindowPos2d
+	glWindowPos2dv
+	glWindowPos2f
+	glWindowPos2fv
+	glWindowPos2i
+	glWindowPos2iv
+	glWindowPos2s
+	glWindowPos2sv
+	glWindowPos3d
+	glWindowPos3dv
+	glWindowPos3f
+	glWindowPos3fv
+	glWindowPos3i
+	glWindowPos3iv
+	glWindowPos3s
+	glWindowPos3sv
+	glVertexAttrib1sARB
+	glVertexAttrib1fARB
+	glVertexAttrib1dARB
+	glVertexAttrib2sARB
+	glVertexAttrib2fARB
+	glVertexAttrib2dARB
+	glVertexAttrib3sARB
+	glVertexAttrib3fARB
+	glVertexAttrib3dARB
+	glVertexAttrib4sARB
+	glVertexAttrib4fARB
+	glVertexAttrib4dARB
+	glVertexAttrib4NubARB
+	glVertexAttrib1svARB
+	glVertexAttrib1fvARB
+	glVertexAttrib1dvARB
+	glVertexAttrib2svARB
+	glVertexAttrib2fvARB
+	glVertexAttrib2dvARB
+	glVertexAttrib3svARB
+	glVertexAttrib3fvARB
+	glVertexAttrib3dvARB
+	glVertexAttrib4bvARB
+	glVertexAttrib4svARB
+	glVertexAttrib4ivARB
+	glVertexAttrib4ubvARB
+	glVertexAttrib4usvARB
+	glVertexAttrib4uivARB
+	glVertexAttrib4fvARB
+	glVertexAttrib4dvARB
+	glVertexAttrib4NbvARB
+	glVertexAttrib4NsvARB
+	glVertexAttrib4NivARB
+	glVertexAttrib4NubvARB
+	glVertexAttrib4NusvARB
+	glVertexAttrib4NuivARB
+	glVertexAttribPointerARB
+	glEnableVertexAttribArrayARB
+	glDisableVertexAttribArrayARB
+	glProgramStringARB
+	glBindProgramARB
+	glDeleteProgramsARB
+	glGenProgramsARB
+	glIsProgramARB
+	glProgramEnvParameter4dARB
+	glProgramEnvParameter4dvARB
+	glProgramEnvParameter4fARB
+	glProgramEnvParameter4fvARB
+	glProgramLocalParameter4dARB
+	glProgramLocalParameter4dvARB
+	glProgramLocalParameter4fARB
+	glProgramLocalParameter4fvARB
+	glGetProgramEnvParameterdvARB
+	glGetProgramEnvParameterfvARB
+	glGetProgramLocalParameterdvARB
+	glGetProgramLocalParameterfvARB
+	glGetProgramivARB
+	glGetProgramStringARB
+	glGetVertexAttribdvARB
+	glGetVertexAttribfvARB
+	glGetVertexAttribivARB
+	glGetVertexAttribPointervARB
+	glProgramNamedParameter4fNV
+	glProgramNamedParameter4dNV
+	glProgramNamedParameter4fvNV
+	glProgramNamedParameter4dvNV
+	glGetProgramNamedParameterfvNV
+	glGetProgramNamedParameterdvNV
+	glBindBufferARB
+	glBufferDataARB
+	glBufferSubDataARB
+	glDeleteBuffersARB
+	glGenBuffersARB
+	glGetBufferParameterivARB
+	glGetBufferPointervARB
+	glGetBufferSubDataARB
+	glIsBufferARB
+	glMapBufferARB
+	glUnmapBufferARB
+	glGenQueriesARB
+	glDeleteQueriesARB
+	glIsQueryARB
+	glBeginQueryARB
+	glEndQueryARB
+	glGetQueryivARB
+	glGetQueryObjectivARB
+	glGetQueryObjectuivARB
+	glBindBuffer
+	glBufferData
+	glBufferSubData
+	glDeleteBuffers
+	glGenBuffers
+	glGetBufferParameteriv
+	glGetBufferPointerv
+	glGetBufferSubData
+	glIsBuffer
+	glMapBuffer
+	glUnmapBuffer
+	glGenQueries
+	glDeleteQueries
+	glIsQuery
+	glBeginQuery
+	glEndQuery
+	glGetQueryiv
+	glGetQueryObjectiv
+	glGetQueryObjectuiv
+;
+; WGL API
+	wglChoosePixelFormat
+	wglCopyContext
+	wglCreateContext
+	wglCreateLayerContext
+	wglDeleteContext
+	wglDescribeLayerPlane
+	wglDescribePixelFormat
+	wglGetCurrentContext
+	wglGetCurrentDC
+	wglGetLayerPaletteEntries
+	wglGetPixelFormat
+	wglGetProcAddress
+	wglMakeCurrent
+	wglRealizeLayerPalette
+	wglSetLayerPaletteEntries
+	wglSetPixelFormat
+	wglShareLists
+	wglSwapBuffers
+	wglSwapLayerBuffers
+	wglUseFontBitmapsA
+	wglUseFontBitmapsW
+	wglUseFontOutlinesA
+	wglUseFontOutlinesW
+	wglGetExtensionsStringARB
diff --git a/mesalib/src/mesa/drivers/windows/gdi/wgl.c b/mesalib/src/mesa/drivers/windows/gdi/wgl.c
index 0756c27cc..33baabee6 100644
--- a/mesalib/src/mesa/drivers/windows/gdi/wgl.c
+++ b/mesalib/src/mesa/drivers/windows/gdi/wgl.c
@@ -1,684 +1,684 @@
-

-/*

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Library General Public

- * License as published by the Free Software Foundation; either

- * version 2 of the License, or (at your option) any later version.

- *

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Library General Public License for more details.

- *

- * You should have received a copy of the GNU Library General Public

- * License along with this library; if not, write to the Free

- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

- *

- */

-

-/*

- * File name 	: wgl.c

- * WGL stuff. Added by Oleg Letsinsky, ajl@ultersys.ru

- * Some things originated from the 3Dfx WGL functions

- */

-

-/* 

- * This file contains the implementation of the wgl* functions for

- * Mesa on Windows.  Since these functions are provided by Windows in

- * GDI/OpenGL, we must supply our versions that work with Mesa here.

- */

-

-

-#include <windows.h>

-

-#include "main/config.h"

-#include "glapi/glapi.h"

-#include "GL/wmesa.h"   /* protos for wmesa* functions */

-

-/*

- * Pixel Format Descriptors

- */

-

-/* Extend the PFD to include DB flag */

-struct __pixelformat__

-{

-    PIXELFORMATDESCRIPTOR pfd;

-    GLboolean doubleBuffered;

-};

-

-

-

-/* These are the PFD's supported by this driver. */

-struct __pixelformat__	pfd[] =

-{

-#if 0 

-    /* Double Buffer, alpha */

-    {	

-	{	

-	    sizeof(PIXELFORMATDESCRIPTOR),	1,

-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|

-	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,

-	    PFD_TYPE_RGBA,

-	    24,	

-	    8, 0,	

-	    8, 8,	

-	    8, 16,	

-	    8, 24,

-	    0, 0, 0, 0, 0,	

-	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	

-	    0, 0, 0,	

-	    0, 0, 0 

-	},

-        GL_TRUE

-    },

-    /* Single Buffer, alpha */

-    {	

-	{	

-	    sizeof(PIXELFORMATDESCRIPTOR),	1,

-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|

-	    PFD_GENERIC_FORMAT,

-	    PFD_TYPE_RGBA,

-	    24,	

-	    8, 0,	

-	    8, 8,	

-	    8, 16,	

-	    8, 24,

-	    0, 0, 0, 0,	0,	

-	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	

-	    0, 0, 0,	

-	    0, 0, 0

-	},

-        GL_FALSE

-    },

-#endif 

-    /* Double Buffer, no alpha */

-    {	

-	{	

-	    sizeof(PIXELFORMATDESCRIPTOR),	1,

-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|

-	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,

-	    PFD_TYPE_RGBA,

-	    24,	

-	    8, 0,

-	    8, 8,

-	    8, 16,

-	    0, 0,

-	    0, 0, 0, 0,	0,

-	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	

-	    0, 0, 0, 

-	    0, 0, 0 

-	},

-        GL_TRUE

-    },

-    /* Single Buffer, no alpha */

-    {	

-	{

-	    sizeof(PIXELFORMATDESCRIPTOR),	1,

-	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|

-	    PFD_GENERIC_FORMAT,

-	    PFD_TYPE_RGBA,

-	    24,	

-	    8, 0,

-	    8, 8,

-	    8, 16,

-	    0, 0,

-	    0, 0, 0, 0,	0,

-	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	

-	    0, 0, 0,

-	    0, 0, 0 

-	},

-        GL_FALSE

-    },

-};

-

-int npfd = sizeof(pfd) / sizeof(pfd[0]);

-

-

-/*

- * Contexts

- */

-

-typedef struct {

-    WMesaContext ctx;

-} MesaWglCtx;

-

-#define MESAWGL_CTX_MAX_COUNT 20

-

-static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];

-

-static unsigned ctx_count = 0;

-static int ctx_current = -1;

-static unsigned curPFD = 0;

-

-static HDC CurrentHDC = 0;

-

-

-WINGDIAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)

-{

-    int i = 0;

-    if (!ctx_count) {

-	for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++) {

-	    wgl_ctx[i].ctx = NULL;

-	}

-    }

-    for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {

-        if ( wgl_ctx[i].ctx == NULL ) {

-            wgl_ctx[i].ctx = 

-		WMesaCreateContext(hdc, NULL, (GLboolean)GL_TRUE,

-				   (GLboolean) (pfd[curPFD-1].doubleBuffered ?

-                                   GL_TRUE : GL_FALSE), 

-				   (GLboolean)(pfd[curPFD-1].pfd.cAlphaBits ? 

-				   GL_TRUE : GL_FALSE) );

-            if (wgl_ctx[i].ctx == NULL)

-                break;

-            ctx_count++;

-            return ((HGLRC)wgl_ctx[i].ctx);

-        }

-    }

-    SetLastError(0);

-    return(NULL);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)

-{

-    int i;

-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {

-    	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ){

-            WMesaMakeCurrent((WMesaContext) hglrc, NULL);

-            WMesaDestroyContext(wgl_ctx[i].ctx);

-            wgl_ctx[i].ctx = NULL;

-            ctx_count--;

-            return(TRUE);

-    	}

-    }

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)

-{

-    if (ctx_current < 0)

-	return 0;

-    else

-	return (HGLRC) wgl_ctx[ctx_current].ctx;

-}

-

-WINGDIAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)

-{

-    return CurrentHDC;

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc, HGLRC hglrc)

-{

-    int i;

-    

-    CurrentHDC = hdc;

-

-    if (!hdc || !hglrc) {

-	WMesaMakeCurrent(NULL, NULL);

-	ctx_current = -1;

-	return TRUE;

-    }

-    

-    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {

-	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ) {

-	    WMesaMakeCurrent( (WMesaContext) hglrc, hdc );

-	    ctx_current = i;

-	    return TRUE;

-	}

-    }

-    return FALSE;

-}

-

-

-WINGDIAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,

-					      CONST 

-					      PIXELFORMATDESCRIPTOR *ppfd)

-{

-    int		i,best = -1,bestdelta = 0x7FFFFFFF,delta;

-    (void) hdc;

-    

-    if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)

-	{

-	    SetLastError(0);

-	    return(0);

-	}

-    for(i = 0; i < npfd;i++)

-	{

-	    delta = 0;

-	    if(

-		(ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&

-		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))

-		continue;

-	    if(

-		(ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&

-		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))

-		continue;

-	    if(

-		(ppfd->dwFlags & PFD_SUPPORT_GDI) &&

-		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_GDI))

-		continue;

-	    if(

-		(ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&

-		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))

-		continue;

-	    if(

-		!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&

-		((ppfd->dwFlags & PFD_DOUBLEBUFFER) != 

-		 (pfd[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))

-		continue;

-	    if(

-		!(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&

-		((ppfd->dwFlags & PFD_STEREO) != 

-		 (pfd[i].pfd.dwFlags & PFD_STEREO)))

-		continue;

-	    if(ppfd->iPixelType != pfd[i].pfd.iPixelType)

-		delta++;

-	    if(ppfd->cAlphaBits != pfd[i].pfd.cAlphaBits)

-		delta++;

-	    if(delta < bestdelta)

-		{

-		    best = i + 1;

-		    bestdelta = delta;

-		    if(bestdelta == 0)

-			break;

-		}

-	}

-    if(best == -1)

-	{

-	    SetLastError(0);

-	    return(0);

-	}

-    return(best);

-}

-

-WINGDIAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,

-					        int iPixelFormat,

-					        UINT nBytes,

-					        LPPIXELFORMATDESCRIPTOR ppfd)

-{

-    (void) hdc;

-    

-    if(ppfd == NULL)

-	return(npfd);

-    if(iPixelFormat < 1 || iPixelFormat > npfd || 

-       nBytes != sizeof(PIXELFORMATDESCRIPTOR))

-	{

-	    SetLastError(0);

-	    return(0);

-	}

-    *ppfd = pfd[iPixelFormat - 1].pfd;

-    return(npfd);

-}

-

-WINGDIAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)

-{

-    PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);

-    if (p)

-	return p;

-    

-    SetLastError(0);

-    return(NULL);

-}

-

-WINGDIAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)

-{

-    (void) hdc;

-    if(curPFD == 0) {

-	SetLastError(0);

-	return(0);

-    }

-    return(curPFD);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,

-					const PIXELFORMATDESCRIPTOR *ppfd)

-{

-    (void) hdc;

-    

-    if(iPixelFormat < 1 || iPixelFormat > npfd || 

-       ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {

-	SetLastError(0);

-	return(FALSE);

-    }

-    curPFD = iPixelFormat;

-    return(TRUE);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)

-{

-    WMesaSwapBuffers(hdc);

-    return TRUE;

-}

-

-static FIXED FixedFromDouble(double d)

-{

-   long l = (long) (d * 65536L);

-   return *(FIXED *) (void *) &l;

-}

-

-

-/*

-** This is cribbed from FX/fxwgl.c, and seems to implement support

-** for bitmap fonts where the wglUseFontBitmapsA() code implements

-** support for outline fonts.  In combination they hopefully give

-** fairly generic support for fonts.

-*/

-static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,

-                                 DWORD numChars, DWORD listBase)

-{

-#define VERIFY(a) (void)(a)

-    

-    TEXTMETRIC metric;

-    BITMAPINFO *dibInfo;

-    HDC bitDevice;

-    COLORREF tempColor;

-    int i;

-    

-    VERIFY(GetTextMetrics(fontDevice, &metric));

-    

-    dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);

-    dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

-    dibInfo->bmiHeader.biPlanes = 1;

-    dibInfo->bmiHeader.biBitCount = 1;

-    dibInfo->bmiHeader.biCompression = BI_RGB;

-    

-    bitDevice = CreateCompatibleDC(fontDevice);

-    

-    /* Swap fore and back colors so the bitmap has the right polarity */

-    tempColor = GetBkColor(bitDevice);

-    SetBkColor(bitDevice, GetTextColor(bitDevice));

-    SetTextColor(bitDevice, tempColor);

-    

-    /* Place chars based on base line */

-    VERIFY(SetTextAlign(bitDevice, TA_BASELINE) != GDI_ERROR ? 1 : 0);

-    

-    for(i = 0; i < (int)numChars; i++) {

-	SIZE size;

-	char curChar;

-	int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;

-	HBITMAP bitObject;

-	HGDIOBJ origBmap;

-	unsigned char *bmap;

-	

-	curChar = (char)(i + firstChar);

-	

-	/* Find how high/wide this character is */

-	VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));

-	

-	/* Create the output bitmap */

-	charWidth = size.cx;

-	charHeight = size.cy;

-	/* Round up to the next multiple of 32 bits */

-	bmapWidth = ((charWidth + 31) / 32) * 32;   

-	bmapHeight = charHeight;

-	bitObject = CreateCompatibleBitmap(bitDevice,

-					   bmapWidth,

-					   bmapHeight);

-	/* VERIFY(bitObject); */

-	

-	/* Assign the output bitmap to the device */

-	origBmap = SelectObject(bitDevice, bitObject);

-	(void) VERIFY(origBmap);

-	

-	VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );

-	

-	/* Use our source font on the device */

-	VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));

-	

-	/* Draw the character */

-	VERIFY(TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1));

-	

-	/* Unselect our bmap object */

-	VERIFY(SelectObject(bitDevice, origBmap));

-	

-	/* Convert the display dependant representation to a 1 bit deep DIB */

-	numBytes = (bmapWidth * bmapHeight) / 8;

-	bmap = malloc(numBytes);

-	dibInfo->bmiHeader.biWidth = bmapWidth;

-	dibInfo->bmiHeader.biHeight = bmapHeight;

-	res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,

-			dibInfo,

-			DIB_RGB_COLORS);

-	/* VERIFY(res); */

-	

-	/* Create the GL object */

-	glNewList(i + listBase, GL_COMPILE);

-	glBitmap(bmapWidth, bmapHeight, 0.0, (GLfloat)metric.tmDescent,

-		 (GLfloat)charWidth, 0.0,

-		 bmap);

-	glEndList();

-	/* CheckGL(); */

-	

-	/* Destroy the bmap object */

-	DeleteObject(bitObject);

-	

-	/* Deallocate the bitmap data */

-	free(bmap);

-    }

-    

-    /* Destroy the DC */

-    VERIFY(DeleteDC(bitDevice));

-    

-    free(dibInfo);

-    

-    return TRUE;

-#undef VERIFY

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,

-					     DWORD count, DWORD listBase)

-{

-    int i;

-    GLuint font_list;

-    DWORD size;

-    GLYPHMETRICS gm;

-    HANDLE hBits;

-    LPSTR lpBits;

-    MAT2 mat;

-    int  success = TRUE;

-    

-    if (count == 0)

-	return FALSE;

-    

-    font_list = listBase;

-    

-    mat.eM11 = FixedFromDouble(1);

-    mat.eM12 = FixedFromDouble(0);

-    mat.eM21 = FixedFromDouble(0);

-    mat.eM22 = FixedFromDouble(-1);

-    

-    memset(&gm,0,sizeof(gm));

-    

-    /*

-    ** If we can't get the glyph outline, it may be because this is a fixed

-    ** font.  Try processing it that way.

-    */

-    if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)

-	== GDI_ERROR ) {

-	return wglUseFontBitmaps_FX( hdc, first, count, listBase );

-    }

-    

-    /*

-    ** Otherwise process all desired characters.

-    */

-    for (i = 0; i < (int)count; i++) {

-	DWORD err;

-	

-	glNewList( font_list+i, GL_COMPILE );

-	

-	/* allocate space for the bitmap/outline */

-	size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, 

-			       &gm, 0, NULL, &mat);

-	if (size == GDI_ERROR) {

-	    glEndList( );

-	    err = GetLastError();

-	    success = FALSE;

-	    continue;

-	}

-	

-	hBits  = GlobalAlloc(GHND, size+1);

-	lpBits = GlobalLock(hBits);

-	

-	err = 

-	    GetGlyphOutline(hdc,         /* handle to device context */

-			    first + i,   /* character to query */

-			    GGO_BITMAP,  /* format of data to return */

-			    &gm,         /* ptr to structure for metrics*/

-			    size,        /* size of buffer for data */

-			    lpBits,      /* pointer to buffer for data */

-			    &mat         /* pointer to transformation */

-			    /* matrix structure */

-		);

-	

-	if (err == GDI_ERROR) {

-	    GlobalUnlock(hBits);

-	    GlobalFree(hBits);

-	    

-	    glEndList( );

-	    err = GetLastError();

-	    success = FALSE;

-	    continue;

-	}

-	

-	glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,

-		 (GLfloat)-gm.gmptGlyphOrigin.x,

-		 (GLfloat)gm.gmptGlyphOrigin.y,

-		 (GLfloat)gm.gmCellIncX,

-		 (GLfloat)gm.gmCellIncY,

-		 (const GLubyte * )lpBits);

-	

-	GlobalUnlock(hBits);

-	GlobalFree(hBits);

-	

-	glEndList( );

-    }

-    

-    return success;

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,

-					HGLRC hglrc2)

-{

-    WMesaShareLists((WMesaContext)hglrc1, (WMesaContext)hglrc2);

-    return(TRUE);

-}

-

-

-

-/* NOT IMPLEMENTED YET */

-WINGDIAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,

-					 HGLRC hglrcDst,

-					 UINT mask)

-{

-    (void) hglrcSrc; (void) hglrcDst; (void) mask;

-    return(FALSE);

-}

-

-WINGDIAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,

-						 int iLayerPlane)

-{

-    SetLastError(0);

-    if (iLayerPlane == 0)

-        return wglCreateContext( hdc );

-    return(NULL);

-}

-

-

-WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,

-					     DWORD first,

-					     DWORD count,

-					     DWORD listBase)

-{

-    (void) hdc; (void) first; (void) count; (void) listBase;

-    return FALSE;

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,

-					      DWORD first,

-					      DWORD count,

-					      DWORD listBase,

-					      FLOAT deviation,

-					      FLOAT extrusion,

-					      int format,

-					      LPGLYPHMETRICSFLOAT lpgmf)

-{

-    (void) hdc; (void) first; (void) count;

-    (void) listBase; (void) deviation; (void) extrusion; (void) format;

-    (void) lpgmf;

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,

-					      DWORD first,

-					      DWORD count,

-					      DWORD listBase,

-					      FLOAT deviation,

-					      FLOAT extrusion,

-					      int format,

-					      LPGLYPHMETRICSFLOAT lpgmf)

-{

-    (void) hdc; (void) first; (void) count;

-    (void) listBase; (void) deviation; (void) extrusion; (void) format;

-    (void) lpgmf;

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,

-						int iPixelFormat,

-						int iLayerPlane,

-						UINT nBytes,

-						LPLAYERPLANEDESCRIPTOR plpd)

-{

-    (void) hdc; (void) iPixelFormat; (void) iLayerPlane; 

-    (void) nBytes; (void) plpd;

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,

-						   int iLayerPlane,

-						   int iStart,

-						   int cEntries,

-						   CONST COLORREF *pcr)

-{

-    (void) hdc; (void) iLayerPlane; (void) iStart; 

-    (void) cEntries; (void) pcr;

-    SetLastError(0);

-    return(0);

-}

-

-WINGDIAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,

-						   int iLayerPlane,

-						   int iStart,

-						   int cEntries,

-						   COLORREF *pcr)

-{

-    (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;

-    SetLastError(0);

-    return(0);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,

-						 int iLayerPlane,

-						 BOOL bRealize)

-{

-    (void) hdc; (void) iLayerPlane; (void) bRealize;

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,

-					      UINT fuPlanes)

-{

-    (void) hdc; (void) fuPlanes;

-    SetLastError(0);

-    return(FALSE);

-}

-

-WINGDIAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc)

-{

-    return "WGL_ARB_extensions_string";

-}

+
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+/*
+ * File name 	: wgl.c
+ * WGL stuff. Added by Oleg Letsinsky, ajl@ultersys.ru
+ * Some things originated from the 3Dfx WGL functions
+ */
+
+/* 
+ * This file contains the implementation of the wgl* functions for
+ * Mesa on Windows.  Since these functions are provided by Windows in
+ * GDI/OpenGL, we must supply our versions that work with Mesa here.
+ */
+
+
+#include <windows.h>
+
+#include "main/config.h"
+#include "glapi/glapi.h"
+#include "GL/wmesa.h"   /* protos for wmesa* functions */
+
+/*
+ * Pixel Format Descriptors
+ */
+
+/* Extend the PFD to include DB flag */
+struct __pixelformat__
+{
+    PIXELFORMATDESCRIPTOR pfd;
+    GLboolean doubleBuffered;
+};
+
+
+
+/* These are the PFD's supported by this driver. */
+struct __pixelformat__	pfd[] =
+{
+#if 0 
+    /* Double Buffer, alpha */
+    {	
+	{	
+	    sizeof(PIXELFORMATDESCRIPTOR),	1,
+	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
+	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
+	    PFD_TYPE_RGBA,
+	    24,	
+	    8, 0,	
+	    8, 8,	
+	    8, 16,	
+	    8, 24,
+	    0, 0, 0, 0, 0,	
+	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	
+	    0, 0, 0,	
+	    0, 0, 0 
+	},
+        GL_TRUE
+    },
+    /* Single Buffer, alpha */
+    {	
+	{	
+	    sizeof(PIXELFORMATDESCRIPTOR),	1,
+	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
+	    PFD_GENERIC_FORMAT,
+	    PFD_TYPE_RGBA,
+	    24,	
+	    8, 0,	
+	    8, 8,	
+	    8, 16,	
+	    8, 24,
+	    0, 0, 0, 0,	0,	
+	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	
+	    0, 0, 0,	
+	    0, 0, 0
+	},
+        GL_FALSE
+    },
+#endif 
+    /* Double Buffer, no alpha */
+    {	
+	{	
+	    sizeof(PIXELFORMATDESCRIPTOR),	1,
+	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
+	    PFD_GENERIC_FORMAT|PFD_DOUBLEBUFFER|PFD_SWAP_COPY,
+	    PFD_TYPE_RGBA,
+	    24,	
+	    8, 0,
+	    8, 8,
+	    8, 16,
+	    0, 0,
+	    0, 0, 0, 0,	0,
+	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	
+	    0, 0, 0, 
+	    0, 0, 0 
+	},
+        GL_TRUE
+    },
+    /* Single Buffer, no alpha */
+    {	
+	{
+	    sizeof(PIXELFORMATDESCRIPTOR),	1,
+	    PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|
+	    PFD_GENERIC_FORMAT,
+	    PFD_TYPE_RGBA,
+	    24,	
+	    8, 0,
+	    8, 8,
+	    8, 16,
+	    0, 0,
+	    0, 0, 0, 0,	0,
+	    DEFAULT_SOFTWARE_DEPTH_BITS,	8,	
+	    0, 0, 0,
+	    0, 0, 0 
+	},
+        GL_FALSE
+    },
+};
+
+int npfd = sizeof(pfd) / sizeof(pfd[0]);
+
+
+/*
+ * Contexts
+ */
+
+typedef struct {
+    WMesaContext ctx;
+} MesaWglCtx;
+
+#define MESAWGL_CTX_MAX_COUNT 20
+
+static MesaWglCtx wgl_ctx[MESAWGL_CTX_MAX_COUNT];
+
+static unsigned ctx_count = 0;
+static int ctx_current = -1;
+static unsigned curPFD = 0;
+
+static HDC CurrentHDC = 0;
+
+
+WINGDIAPI HGLRC GLAPIENTRY wglCreateContext(HDC hdc)
+{
+    int i = 0;
+    if (!ctx_count) {
+	for(i=0;i<MESAWGL_CTX_MAX_COUNT;i++) {
+	    wgl_ctx[i].ctx = NULL;
+	}
+    }
+    for( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
+        if ( wgl_ctx[i].ctx == NULL ) {
+            wgl_ctx[i].ctx = 
+		WMesaCreateContext(hdc, NULL, (GLboolean)GL_TRUE,
+				   (GLboolean) (pfd[curPFD-1].doubleBuffered ?
+                                   GL_TRUE : GL_FALSE), 
+				   (GLboolean)(pfd[curPFD-1].pfd.cAlphaBits ? 
+				   GL_TRUE : GL_FALSE) );
+            if (wgl_ctx[i].ctx == NULL)
+                break;
+            ctx_count++;
+            return ((HGLRC)wgl_ctx[i].ctx);
+        }
+    }
+    SetLastError(0);
+    return(NULL);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglDeleteContext(HGLRC hglrc)
+{
+    int i;
+    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
+    	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ){
+            WMesaMakeCurrent((WMesaContext) hglrc, NULL);
+            WMesaDestroyContext(wgl_ctx[i].ctx);
+            wgl_ctx[i].ctx = NULL;
+            ctx_count--;
+            return(TRUE);
+    	}
+    }
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI HGLRC GLAPIENTRY wglGetCurrentContext(VOID)
+{
+    if (ctx_current < 0)
+	return 0;
+    else
+	return (HGLRC) wgl_ctx[ctx_current].ctx;
+}
+
+WINGDIAPI HDC GLAPIENTRY wglGetCurrentDC(VOID)
+{
+    return CurrentHDC;
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglMakeCurrent(HDC hdc, HGLRC hglrc)
+{
+    int i;
+    
+    CurrentHDC = hdc;
+
+    if (!hdc || !hglrc) {
+	WMesaMakeCurrent(NULL, NULL);
+	ctx_current = -1;
+	return TRUE;
+    }
+    
+    for ( i = 0; i < MESAWGL_CTX_MAX_COUNT; i++ ) {
+	if ( wgl_ctx[i].ctx == (WMesaContext) hglrc ) {
+	    WMesaMakeCurrent( (WMesaContext) hglrc, hdc );
+	    ctx_current = i;
+	    return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+
+WINGDIAPI int GLAPIENTRY wglChoosePixelFormat(HDC hdc,
+					      CONST 
+					      PIXELFORMATDESCRIPTOR *ppfd)
+{
+    int		i,best = -1,bestdelta = 0x7FFFFFFF,delta;
+    (void) hdc;
+    
+    if(ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR) || ppfd->nVersion != 1)
+	{
+	    SetLastError(0);
+	    return(0);
+	}
+    for(i = 0; i < npfd;i++)
+	{
+	    delta = 0;
+	    if(
+		(ppfd->dwFlags & PFD_DRAW_TO_WINDOW) &&
+		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_WINDOW))
+		continue;
+	    if(
+		(ppfd->dwFlags & PFD_DRAW_TO_BITMAP) &&
+		!(pfd[i].pfd.dwFlags & PFD_DRAW_TO_BITMAP))
+		continue;
+	    if(
+		(ppfd->dwFlags & PFD_SUPPORT_GDI) &&
+		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_GDI))
+		continue;
+	    if(
+		(ppfd->dwFlags & PFD_SUPPORT_OPENGL) &&
+		!(pfd[i].pfd.dwFlags & PFD_SUPPORT_OPENGL))
+		continue;
+	    if(
+		!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) &&
+		((ppfd->dwFlags & PFD_DOUBLEBUFFER) != 
+		 (pfd[i].pfd.dwFlags & PFD_DOUBLEBUFFER)))
+		continue;
+	    if(
+		!(ppfd->dwFlags & PFD_STEREO_DONTCARE) &&
+		((ppfd->dwFlags & PFD_STEREO) != 
+		 (pfd[i].pfd.dwFlags & PFD_STEREO)))
+		continue;
+	    if(ppfd->iPixelType != pfd[i].pfd.iPixelType)
+		delta++;
+	    if(ppfd->cAlphaBits != pfd[i].pfd.cAlphaBits)
+		delta++;
+	    if(delta < bestdelta)
+		{
+		    best = i + 1;
+		    bestdelta = delta;
+		    if(bestdelta == 0)
+			break;
+		}
+	}
+    if(best == -1)
+	{
+	    SetLastError(0);
+	    return(0);
+	}
+    return(best);
+}
+
+WINGDIAPI int GLAPIENTRY wglDescribePixelFormat(HDC hdc,
+					        int iPixelFormat,
+					        UINT nBytes,
+					        LPPIXELFORMATDESCRIPTOR ppfd)
+{
+    (void) hdc;
+    
+    if(ppfd == NULL)
+	return(npfd);
+    if(iPixelFormat < 1 || iPixelFormat > npfd || 
+       nBytes != sizeof(PIXELFORMATDESCRIPTOR))
+	{
+	    SetLastError(0);
+	    return(0);
+	}
+    *ppfd = pfd[iPixelFormat - 1].pfd;
+    return(npfd);
+}
+
+WINGDIAPI PROC GLAPIENTRY wglGetProcAddress(LPCSTR lpszProc)
+{
+    PROC p = (PROC) _glapi_get_proc_address((const char *) lpszProc);
+    if (p)
+	return p;
+    
+    SetLastError(0);
+    return(NULL);
+}
+
+WINGDIAPI int GLAPIENTRY wglGetPixelFormat(HDC hdc)
+{
+    (void) hdc;
+    if(curPFD == 0) {
+	SetLastError(0);
+	return(0);
+    }
+    return(curPFD);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglSetPixelFormat(HDC hdc,int iPixelFormat,
+					const PIXELFORMATDESCRIPTOR *ppfd)
+{
+    (void) hdc;
+    
+    if(iPixelFormat < 1 || iPixelFormat > npfd || 
+       ppfd->nSize != sizeof(PIXELFORMATDESCRIPTOR)) {
+	SetLastError(0);
+	return(FALSE);
+    }
+    curPFD = iPixelFormat;
+    return(TRUE);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglSwapBuffers(HDC hdc)
+{
+    WMesaSwapBuffers(hdc);
+    return TRUE;
+}
+
+static FIXED FixedFromDouble(double d)
+{
+   long l = (long) (d * 65536L);
+   return *(FIXED *) (void *) &l;
+}
+
+
+/*
+** This is cribbed from FX/fxwgl.c, and seems to implement support
+** for bitmap fonts where the wglUseFontBitmapsA() code implements
+** support for outline fonts.  In combination they hopefully give
+** fairly generic support for fonts.
+*/
+static BOOL wglUseFontBitmaps_FX(HDC fontDevice, DWORD firstChar,
+                                 DWORD numChars, DWORD listBase)
+{
+#define VERIFY(a) (void)(a)
+    
+    TEXTMETRIC metric;
+    BITMAPINFO *dibInfo;
+    HDC bitDevice;
+    COLORREF tempColor;
+    int i;
+    
+    VERIFY(GetTextMetrics(fontDevice, &metric));
+    
+    dibInfo = (BITMAPINFO *) calloc(sizeof(BITMAPINFO) + sizeof(RGBQUAD), 1);
+    dibInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    dibInfo->bmiHeader.biPlanes = 1;
+    dibInfo->bmiHeader.biBitCount = 1;
+    dibInfo->bmiHeader.biCompression = BI_RGB;
+    
+    bitDevice = CreateCompatibleDC(fontDevice);
+    
+    /* Swap fore and back colors so the bitmap has the right polarity */
+    tempColor = GetBkColor(bitDevice);
+    SetBkColor(bitDevice, GetTextColor(bitDevice));
+    SetTextColor(bitDevice, tempColor);
+    
+    /* Place chars based on base line */
+    VERIFY(SetTextAlign(bitDevice, TA_BASELINE) != GDI_ERROR ? 1 : 0);
+    
+    for(i = 0; i < (int)numChars; i++) {
+	SIZE size;
+	char curChar;
+	int charWidth,charHeight,bmapWidth,bmapHeight,numBytes,res;
+	HBITMAP bitObject;
+	HGDIOBJ origBmap;
+	unsigned char *bmap;
+	
+	curChar = (char)(i + firstChar);
+	
+	/* Find how high/wide this character is */
+	VERIFY(GetTextExtentPoint32(bitDevice, &curChar, 1, &size));
+	
+	/* Create the output bitmap */
+	charWidth = size.cx;
+	charHeight = size.cy;
+	/* Round up to the next multiple of 32 bits */
+	bmapWidth = ((charWidth + 31) / 32) * 32;   
+	bmapHeight = charHeight;
+	bitObject = CreateCompatibleBitmap(bitDevice,
+					   bmapWidth,
+					   bmapHeight);
+	/* VERIFY(bitObject); */
+	
+	/* Assign the output bitmap to the device */
+	origBmap = SelectObject(bitDevice, bitObject);
+	(void) VERIFY(origBmap);
+	
+	VERIFY( PatBlt( bitDevice, 0, 0, bmapWidth, bmapHeight,BLACKNESS ) );
+	
+	/* Use our source font on the device */
+	VERIFY(SelectObject(bitDevice, GetCurrentObject(fontDevice,OBJ_FONT)));
+	
+	/* Draw the character */
+	VERIFY(TextOut(bitDevice, 0, metric.tmAscent, &curChar, 1));
+	
+	/* Unselect our bmap object */
+	VERIFY(SelectObject(bitDevice, origBmap));
+	
+	/* Convert the display dependant representation to a 1 bit deep DIB */
+	numBytes = (bmapWidth * bmapHeight) / 8;
+	bmap = malloc(numBytes);
+	dibInfo->bmiHeader.biWidth = bmapWidth;
+	dibInfo->bmiHeader.biHeight = bmapHeight;
+	res = GetDIBits(bitDevice, bitObject, 0, bmapHeight, bmap,
+			dibInfo,
+			DIB_RGB_COLORS);
+	/* VERIFY(res); */
+	
+	/* Create the GL object */
+	glNewList(i + listBase, GL_COMPILE);
+	glBitmap(bmapWidth, bmapHeight, 0.0, (GLfloat)metric.tmDescent,
+		 (GLfloat)charWidth, 0.0,
+		 bmap);
+	glEndList();
+	/* CheckGL(); */
+	
+	/* Destroy the bmap object */
+	DeleteObject(bitObject);
+	
+	/* Deallocate the bitmap data */
+	free(bmap);
+    }
+    
+    /* Destroy the DC */
+    VERIFY(DeleteDC(bitDevice));
+    
+    free(dibInfo);
+    
+    return TRUE;
+#undef VERIFY
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsA(HDC hdc, DWORD first,
+					     DWORD count, DWORD listBase)
+{
+    int i;
+    GLuint font_list;
+    DWORD size;
+    GLYPHMETRICS gm;
+    HANDLE hBits;
+    LPSTR lpBits;
+    MAT2 mat;
+    int  success = TRUE;
+    
+    if (count == 0)
+	return FALSE;
+    
+    font_list = listBase;
+    
+    mat.eM11 = FixedFromDouble(1);
+    mat.eM12 = FixedFromDouble(0);
+    mat.eM21 = FixedFromDouble(0);
+    mat.eM22 = FixedFromDouble(-1);
+    
+    memset(&gm,0,sizeof(gm));
+    
+    /*
+    ** If we can't get the glyph outline, it may be because this is a fixed
+    ** font.  Try processing it that way.
+    */
+    if( GetGlyphOutline(hdc, first, GGO_BITMAP, &gm, 0, NULL, &mat)
+	== GDI_ERROR ) {
+	return wglUseFontBitmaps_FX( hdc, first, count, listBase );
+    }
+    
+    /*
+    ** Otherwise process all desired characters.
+    */
+    for (i = 0; i < (int)count; i++) {
+	DWORD err;
+	
+	glNewList( font_list+i, GL_COMPILE );
+	
+	/* allocate space for the bitmap/outline */
+	size = GetGlyphOutline(hdc, first + i, GGO_BITMAP, 
+			       &gm, 0, NULL, &mat);
+	if (size == GDI_ERROR) {
+	    glEndList( );
+	    err = GetLastError();
+	    success = FALSE;
+	    continue;
+	}
+	
+	hBits  = GlobalAlloc(GHND, size+1);
+	lpBits = GlobalLock(hBits);
+	
+	err = 
+	    GetGlyphOutline(hdc,         /* handle to device context */
+			    first + i,   /* character to query */
+			    GGO_BITMAP,  /* format of data to return */
+			    &gm,         /* ptr to structure for metrics*/
+			    size,        /* size of buffer for data */
+			    lpBits,      /* pointer to buffer for data */
+			    &mat         /* pointer to transformation */
+			    /* matrix structure */
+		);
+	
+	if (err == GDI_ERROR) {
+	    GlobalUnlock(hBits);
+	    GlobalFree(hBits);
+	    
+	    glEndList( );
+	    err = GetLastError();
+	    success = FALSE;
+	    continue;
+	}
+	
+	glBitmap(gm.gmBlackBoxX,gm.gmBlackBoxY,
+		 (GLfloat)-gm.gmptGlyphOrigin.x,
+		 (GLfloat)gm.gmptGlyphOrigin.y,
+		 (GLfloat)gm.gmCellIncX,
+		 (GLfloat)gm.gmCellIncY,
+		 (const GLubyte * )lpBits);
+	
+	GlobalUnlock(hBits);
+	GlobalFree(hBits);
+	
+	glEndList( );
+    }
+    
+    return success;
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglShareLists(HGLRC hglrc1,
+					HGLRC hglrc2)
+{
+    WMesaShareLists((WMesaContext)hglrc1, (WMesaContext)hglrc2);
+    return(TRUE);
+}
+
+
+
+/* NOT IMPLEMENTED YET */
+WINGDIAPI BOOL GLAPIENTRY wglCopyContext(HGLRC hglrcSrc,
+					 HGLRC hglrcDst,
+					 UINT mask)
+{
+    (void) hglrcSrc; (void) hglrcDst; (void) mask;
+    return(FALSE);
+}
+
+WINGDIAPI HGLRC GLAPIENTRY wglCreateLayerContext(HDC hdc,
+						 int iLayerPlane)
+{
+    SetLastError(0);
+    if (iLayerPlane == 0)
+        return wglCreateContext( hdc );
+    return(NULL);
+}
+
+
+WINGDIAPI BOOL GLAPIENTRY wglUseFontBitmapsW(HDC hdc,
+					     DWORD first,
+					     DWORD count,
+					     DWORD listBase)
+{
+    (void) hdc; (void) first; (void) count; (void) listBase;
+    return FALSE;
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesA(HDC hdc,
+					      DWORD first,
+					      DWORD count,
+					      DWORD listBase,
+					      FLOAT deviation,
+					      FLOAT extrusion,
+					      int format,
+					      LPGLYPHMETRICSFLOAT lpgmf)
+{
+    (void) hdc; (void) first; (void) count;
+    (void) listBase; (void) deviation; (void) extrusion; (void) format;
+    (void) lpgmf;
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglUseFontOutlinesW(HDC hdc,
+					      DWORD first,
+					      DWORD count,
+					      DWORD listBase,
+					      FLOAT deviation,
+					      FLOAT extrusion,
+					      int format,
+					      LPGLYPHMETRICSFLOAT lpgmf)
+{
+    (void) hdc; (void) first; (void) count;
+    (void) listBase; (void) deviation; (void) extrusion; (void) format;
+    (void) lpgmf;
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglDescribeLayerPlane(HDC hdc,
+						int iPixelFormat,
+						int iLayerPlane,
+						UINT nBytes,
+						LPLAYERPLANEDESCRIPTOR plpd)
+{
+    (void) hdc; (void) iPixelFormat; (void) iLayerPlane; 
+    (void) nBytes; (void) plpd;
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI int GLAPIENTRY wglSetLayerPaletteEntries(HDC hdc,
+						   int iLayerPlane,
+						   int iStart,
+						   int cEntries,
+						   CONST COLORREF *pcr)
+{
+    (void) hdc; (void) iLayerPlane; (void) iStart; 
+    (void) cEntries; (void) pcr;
+    SetLastError(0);
+    return(0);
+}
+
+WINGDIAPI int GLAPIENTRY wglGetLayerPaletteEntries(HDC hdc,
+						   int iLayerPlane,
+						   int iStart,
+						   int cEntries,
+						   COLORREF *pcr)
+{
+    (void) hdc; (void) iLayerPlane; (void) iStart; (void) cEntries; (void) pcr;
+    SetLastError(0);
+    return(0);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglRealizeLayerPalette(HDC hdc,
+						 int iLayerPlane,
+						 BOOL bRealize)
+{
+    (void) hdc; (void) iLayerPlane; (void) bRealize;
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI BOOL GLAPIENTRY wglSwapLayerBuffers(HDC hdc,
+					      UINT fuPlanes)
+{
+    (void) hdc; (void) fuPlanes;
+    SetLastError(0);
+    return(FALSE);
+}
+
+WINGDIAPI const char * GLAPIENTRY wglGetExtensionsStringARB(HDC hdc)
+{
+    return "WGL_ARB_extensions_string";
+}
diff --git a/mesalib/src/mesa/drivers/windows/gdi/wmesa.c b/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
index 47580c4e9..35a150d06 100644
--- a/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
+++ b/mesalib/src/mesa/drivers/windows/gdi/wmesa.c
@@ -1,1658 +1,1658 @@
-/*

- * Windows (Win32/Win64) device driver for Mesa

- *

- */

-

-#include "wmesadef.h"

-#include "colors.h"

-#include "GL/wmesa.h"

-#include <winuser.h>

-#include "main/context.h"

-#include "main/extensions.h"

-#include "main/framebuffer.h"

-#include "main/renderbuffer.h"

-#include "main/macros.h"

-#include "drivers/common/driverfuncs.h"

-#include "drivers/common/meta.h"

-#include "vbo/vbo.h"

-#include "swrast/swrast.h"

-#include "swrast_setup/swrast_setup.h"

-#include "tnl/tnl.h"

-#include "tnl/t_context.h"

-#include "tnl/t_pipeline.h"

-

-

-/* linked list of our Framebuffers (windows) */

-static WMesaFramebuffer FirstFramebuffer = NULL;

-

-

-/**

- * Create a new WMesaFramebuffer object which will correspond to the

- * given HDC (Window handle).

- */

-static WMesaFramebuffer

-wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)

-{

-    WMesaFramebuffer pwfb

-        = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));

-    if (pwfb) {

-        _mesa_initialize_window_framebuffer(&pwfb->Base, visual);

-        pwfb->hDC = hdc;

-        /* insert at head of list */

-        pwfb->next = FirstFramebuffer;

-        FirstFramebuffer = pwfb;

-    }

-    return pwfb;

-}

-

-/**

- * Given an hdc, free the corresponding WMesaFramebuffer

- */

-static void

-wmesa_free_framebuffer(HDC hdc)

-{

-    WMesaFramebuffer pwfb, prev;

-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {

-        if (pwfb->hDC == hdc)

-            break;

-	prev = pwfb;

-    }

-    if (pwfb) {

-        struct gl_framebuffer *fb;

-	if (pwfb == FirstFramebuffer)

-	    FirstFramebuffer = pwfb->next;

-	else

-	    prev->next = pwfb->next;

-        fb = &pwfb->Base;

-        _mesa_reference_framebuffer(&fb, NULL); 

-    }

-}

-

-/**

- * Given an hdc, return the corresponding WMesaFramebuffer

- */

-static WMesaFramebuffer

-wmesa_lookup_framebuffer(HDC hdc)

-{

-    WMesaFramebuffer pwfb;

-    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {

-        if (pwfb->hDC == hdc)

-            return pwfb;

-    }

-    return NULL;

-}

-

-

-/**

- * Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer.

- */

-static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb)

-{

-    return (WMesaFramebuffer) fb;

-}

-

-

-/**

- * Given a struct gl_context, return the corresponding WMesaContext.

- */

-static WMesaContext wmesa_context(const struct gl_context *ctx)

-{

-    return (WMesaContext) ctx;

-}

-

-

-/*

- * Every driver should implement a GetString function in order to

- * return a meaningful GL_RENDERER string.

- */

-static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name)

-{

-    return (name == GL_RENDERER) ? 

-	(GLubyte *) "Mesa Windows GDI Driver" : NULL;

-}

-

-

-/*

- * Determine the pixel format based on the pixel size.

- */

-static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)

-{

-    pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);

-

-    /* Only 16 and 32 bit targets are supported now */

-    assert(pwfb->cColorBits == 0 ||

-	   pwfb->cColorBits == 16 || 

-	   pwfb->cColorBits == 24 || 

-	   pwfb->cColorBits == 32);

-

-    switch(pwfb->cColorBits){

-    case 8:

-	pwfb->pixelformat = PF_INDEX8;

-	break;

-    case 16:

-	pwfb->pixelformat = PF_5R6G5B;

-	break;

-    case 24:

-    case 32:

-	pwfb->pixelformat = PF_8R8G8B;

-	break;

-    default:

-	pwfb->pixelformat = PF_BADFORMAT;

-    }

-}

-

-

-/**

- * Create DIB for back buffer.

- * We write into this memory with the span routines and then blit it

- * to the window on a buffer swap.

- */

-static BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize)

-{

-    LPBITMAPINFO pbmi = &(pwfb->bmi);

-    HDC          hic;

-

-    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

-    pbmi->bmiHeader.biWidth = lxSize;

-    pbmi->bmiHeader.biHeight= -lySize;

-    pbmi->bmiHeader.biPlanes = 1;

-    pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL);

-    pbmi->bmiHeader.biCompression = BI_RGB;

-    pbmi->bmiHeader.biSizeImage = 0;

-    pbmi->bmiHeader.biXPelsPerMeter = 0;

-    pbmi->bmiHeader.biYPelsPerMeter = 0;

-    pbmi->bmiHeader.biClrUsed = 0;

-    pbmi->bmiHeader.biClrImportant = 0;

-    

-    pwfb->cColorBits = pbmi->bmiHeader.biBitCount;

-    pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3;

-    

-    hic = CreateIC("display", NULL, NULL, NULL);

-    pwfb->dib_hDC = CreateCompatibleDC(hic);

-    

-    pwfb->hbmDIB = CreateDIBSection(hic,

-				   &pwfb->bmi,

-				   DIB_RGB_COLORS,

-				   (void **)&(pwfb->pbPixels),

-				   0,

-				   0);

-    pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB);

-    

-    DeleteDC(hic);

-

-    wmSetPixelFormat(pwfb, pwfb->hDC);

-    return TRUE;

-}

-

-

-static void wmDeleteBackingStore(WMesaFramebuffer pwfb)

-{

-    if (pwfb->hbmDIB) {

-	SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap);

-	DeleteDC(pwfb->dib_hDC);

-	DeleteObject(pwfb->hbmDIB);

-    }

-}

-

-

-/**

- * Find the width and height of the window named by hdc.

- */

-static void

-get_window_size(HDC hdc, GLuint *width, GLuint *height)

-{

-    if (WindowFromDC(hdc)) {

-        RECT rect;

-        GetClientRect(WindowFromDC(hdc), &rect);

-        *width = rect.right - rect.left;

-        *height = rect.bottom - rect.top;

-    }

-    else { /* Memory context */

-        /* From contributed code - use the size of the desktop

-         * for the size of a memory context (?) */

-        *width = GetDeviceCaps(hdc, HORZRES);

-        *height = GetDeviceCaps(hdc, VERTRES);

-    }

-}

-

-

-static void

-wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height)

-{

-    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);

-    get_window_size(pwfb->hDC, width, height);

-}

-

-

-static void wmesa_flush(struct gl_context *ctx)

-{

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer);

-

-    if (ctx->Visual.doubleBufferMode == 1) {

-	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,

-	       pwfb->dib_hDC, 0, 0, SRCCOPY);

-    }

-    else {

-	/* Do nothing for single buffer */

-    }

-}

-

-

-/**********************************************************************/

-/*****                   CLEAR Functions                          *****/

-/**********************************************************************/

-

-/* If we do not implement these, Mesa clears the buffers via the pixel

- * span writing interface, which is very slow for a clear operation.

- */

-

-/*

- * Set the color used to clear the color buffer.

- */

-static void clear_color(struct gl_context *ctx, const GLfloat color[4])

-{

-    WMesaContext pwc = wmesa_context(ctx);

-    GLubyte col[3];

-

-    CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);

-    CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);

-    CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);

-    pwc->clearColorRef = RGB(col[0], col[1], col[2]);

-    DeleteObject(pwc->clearPen);

-    DeleteObject(pwc->clearBrush);

-    pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef); 

-    pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef); 

-}

-

-

-/* 

- * Clear the specified region of the color buffer using the clear color 

- * or index as specified by one of the two functions above. 

- * 

- * This procedure clears either the front and/or the back COLOR buffers. 

- * Only the "left" buffer is cleared since we are not stereo. 

- * Clearing of the other non-color buffers is left to the swrast. 

- */ 

-

-static void clear(struct gl_context *ctx, GLbitfield mask)

-{

-#define FLIP(Y)  (ctx->DrawBuffer->Height - (Y) - 1)

-    const GLint x = ctx->DrawBuffer->_Xmin;

-    const GLint y = ctx->DrawBuffer->_Ymin;

-    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;

-    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;

-

-    WMesaContext pwc = wmesa_context(ctx);

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    int done = 0;

-

-    /* Let swrast do all the work if the masks are not set to

-     * clear all channels. */

-    if (!ctx->Color.ColorMask[0][0] ||

-	!ctx->Color.ColorMask[0][1] ||

-	!ctx->Color.ColorMask[0][2] ||

-	!ctx->Color.ColorMask[0][3]) {

-	_swrast_Clear(ctx, mask);

-	return;

-    }

-

-    /* Back buffer */

-    if (mask & BUFFER_BIT_BACK_LEFT) { 

-	

-	int     i, rowSize; 

-	UINT    bytesPerPixel = pwfb->cColorBits / 8; 

-	LPBYTE  lpb, clearRow;

-	LPWORD  lpw;

-	BYTE    bColor; 

-	WORD    wColor; 

-	BYTE    r, g, b; 

-	DWORD   dwColor; 

-	LPDWORD lpdw; 

-	

-	/* Try for a fast clear - clearing entire buffer with a single

-	 * byte value. */

-	if (width == ctx->DrawBuffer->Width &&

-            height == ctx->DrawBuffer->Height) { /* entire buffer */

-	    /* Now check for an easy clear value */

-	    switch (bytesPerPixel) {

-	    case 1:

-		bColor = BGR8(GetRValue(pwc->clearColorRef), 

-			      GetGValue(pwc->clearColorRef), 

-			      GetBValue(pwc->clearColorRef));

-		memset(pwfb->pbPixels, bColor, 

-		       pwfb->ScanWidth * height);

-		done = 1;

-		break;

-	    case 2:

-		wColor = BGR16(GetRValue(pwc->clearColorRef), 

-			       GetGValue(pwc->clearColorRef), 

-			       GetBValue(pwc->clearColorRef)); 

-		if (((wColor >> 8) & 0xff) == (wColor & 0xff)) {

-		    memset(pwfb->pbPixels, wColor & 0xff, 

-			   pwfb->ScanWidth * height);

-		    done = 1;

-		}

-		break;

-	    case 3:

-		/* fall through */

-	    case 4:

-		if (GetRValue(pwc->clearColorRef) == 

-		    GetGValue(pwc->clearColorRef) &&

-		    GetRValue(pwc->clearColorRef) == 

-		    GetBValue(pwc->clearColorRef)) {

-		    memset(pwfb->pbPixels, 

-			   GetRValue(pwc->clearColorRef), 

-			   pwfb->ScanWidth * height);

-		    done = 1;

-		}

-		break;

-	    default:

-		break;

-	    }

-	} /* all */

-

-	if (!done) {

-	    /* Need to clear a row at a time.  Begin by setting the first

-	     * row in the area to be cleared to the clear color. */

-	    

-	    clearRow = pwfb->pbPixels + 

-		pwfb->ScanWidth * FLIP(y) +

-		bytesPerPixel * x; 

-	    switch (bytesPerPixel) {

-	    case 1:

-		lpb = clearRow;

-		bColor = BGR8(GetRValue(pwc->clearColorRef), 

-			      GetGValue(pwc->clearColorRef), 

-			      GetBValue(pwc->clearColorRef));

-		memset(lpb, bColor, width);

-		break;

-	    case 2:

-		lpw = (LPWORD)clearRow;

-		wColor = BGR16(GetRValue(pwc->clearColorRef), 

-			       GetGValue(pwc->clearColorRef), 

-			       GetBValue(pwc->clearColorRef)); 

-		for (i=0; i<width; i++)

-		    *lpw++ = wColor;

-		break;

-	    case 3: 

-		lpb = clearRow;

-		r = GetRValue(pwc->clearColorRef); 

-		g = GetGValue(pwc->clearColorRef); 

-		b = GetBValue(pwc->clearColorRef); 

-		for (i=0; i<width; i++) {

-		    *lpb++ = b; 

-		    *lpb++ = g; 

-		    *lpb++ = r; 

-		} 

-		break;

-	    case 4: 

-		lpdw = (LPDWORD)clearRow; 

-		dwColor = BGR32(GetRValue(pwc->clearColorRef), 

-				GetGValue(pwc->clearColorRef), 

-				GetBValue(pwc->clearColorRef)); 

-		for (i=0; i<width; i++)

-		    *lpdw++ = dwColor;

-		break;

-	    default:

-		break;

-	    } /* switch */

-	    

-	    /* copy cleared row to other rows in buffer */

-	    lpb = clearRow - pwfb->ScanWidth;

-	    rowSize = width * bytesPerPixel;

-	    for (i=1; i<height; i++) { 

-		memcpy(lpb, clearRow, rowSize); 

-		lpb -= pwfb->ScanWidth; 

-	    } 

-	} /* not done */

-	mask &= ~BUFFER_BIT_BACK_LEFT;

-    } /* back buffer */ 

-

-    /* front buffer */

-    if (mask & BUFFER_BIT_FRONT_LEFT) { 

-	HDC DC = pwc->hDC; 

-	HPEN Old_Pen = SelectObject(DC, pwc->clearPen); 

-	HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush);

-	Rectangle(DC,

-		  x,

-		  FLIP(y) + 1,

-		  x + width + 1,

-		  FLIP(y) - height + 1);

-	SelectObject(DC, Old_Pen); 

-	SelectObject(DC, Old_Brush); 

-	mask &= ~BUFFER_BIT_FRONT_LEFT;

-    } /* front buffer */ 

-    

-    /* Call swrast if there is anything left to clear (like DEPTH) */ 

-    if (mask) 

-	_swrast_Clear(ctx, mask);

-  

-#undef FLIP

-} 

-

-

-/**********************************************************************/

-/*****                   PIXEL Functions                          *****/

-/**********************************************************************/

-

-#define FLIP(Y)  (rb->Height - (Y) - 1)

-

-

-/**

- ** Front Buffer reading/writing

- ** These are slow, but work with all non-indexed visual types.

- **/

-

-/* Write a horizontal span of RGBA color pixels with a boolean mask. */

-static void write_rgba_span_front(struct gl_context *ctx, 

-				  struct gl_renderbuffer *rb, 

-				  GLuint n, GLint x, GLint y,

-				  const void *values, 

-				  const GLubyte *mask)

-{

-   const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-   WMesaContext pwc = wmesa_context(ctx);

-   WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC);

-   HBITMAP bmp=0;

-   HDC mdc=0;

-   typedef union

-   {

-      unsigned i;

-      struct {

-         unsigned b:8, g:8, r:8, a:8;

-      };

-   } BGRA;

-   BGRA *bgra, c;

-   GLuint i;

-

-   if (n < 16) {   // the value 16 is just guessed

-      y=FLIP(y);

-      if (mask) {

-         for (i=0; i<n; i++)

-            if (mask[i])

-               SetPixel(pwc->hDC, x+i, y,

-                        RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

-      }

-      else {

-         for (i=0; i<n; i++)

-            SetPixel(pwc->hDC, x+i, y,

-                     RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));

-      }

-   }

-   else {

-      if (!pwfb) {

-         _mesa_problem(NULL, "wmesa: write_rgba_span_front on unknown hdc");

-         return;

-      }

-      bgra=malloc(n*sizeof(BGRA));

-      if (!bgra) {

-         _mesa_problem(NULL, "wmesa: write_rgba_span_front: out of memory");

-         return;

-      }

-      c.a=0;

-      if (mask) {

-         for (i=0; i<n; i++) {

-            if (mask[i]) {

-               c.r=rgba[i][RCOMP];

-               c.g=rgba[i][GCOMP];

-               c.b=rgba[i][BCOMP];

-               c.a=rgba[i][ACOMP];

-               bgra[i]=c;

-            }

-            else

-               bgra[i].i=0;

-         }

-      }

-      else {

-         for (i=0; i<n; i++) {

-            c.r=rgba[i][RCOMP];

-            c.g=rgba[i][GCOMP];

-            c.b=rgba[i][BCOMP];

-            c.a=rgba[i][ACOMP];

-            bgra[i]=c;

-         }

-      }

-      bmp=CreateBitmap(n, 1,  1, 32, bgra);

-      mdc=CreateCompatibleDC(pwfb->hDC);

-      SelectObject(mdc, bmp);

-      y=FLIP(y);

-      BitBlt(pwfb->hDC, x, y, n, 1, mdc, 0, 0, SRCCOPY);

-      SelectObject(mdc, 0);

-      DeleteObject(bmp);

-      DeleteDC(mdc);

-      free(bgra);

-   }

-}

-

-/* Write a horizontal span of RGB color pixels with a boolean mask. */

-static void write_rgb_span_front(struct gl_context *ctx, 

-				 struct gl_renderbuffer *rb, 

-				 GLuint n, GLint x, GLint y,

-				 const void *values, 

-				 const GLubyte *mask)

-{

-    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;

-    WMesaContext pwc = wmesa_context(ctx);

-    GLuint i;

-    

-    (void) ctx;

-    y=FLIP(y);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-		SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 

-					       rgb[i][BCOMP]));

-    }

-    else {

-	for (i=0; i<n; i++)

-	    SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 

-					   rgb[i][BCOMP]));

-    }

-    

-}

-

-/*

- * Write a horizontal span of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_span_front(struct gl_context *ctx, 

-                                       struct gl_renderbuffer *rb,

-                                       GLuint n, GLint x, GLint y,

-                                       const void *value, 

-                                       const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    GLuint i;

-    WMesaContext pwc = wmesa_context(ctx);

-    COLORREF colorref;

-

-    (void) ctx;

-    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);

-    y=FLIP(y);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-		SetPixel(pwc->hDC, x+i, y, colorref);

-    }

-    else

-	for (i=0; i<n; i++)

-	    SetPixel(pwc->hDC, x+i, y, colorref);

-

-}

-

-/* Write an array of RGBA pixels with a boolean mask. */

-static void write_rgba_pixels_front(struct gl_context *ctx, 

-                                    struct gl_renderbuffer *rb,

-                                    GLuint n, 

-                                    const GLint x[], const GLint y[],

-                                    const void *values, 

-                                    const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    GLuint i;

-    WMesaContext pwc = wmesa_context(ctx);

-    (void) ctx;

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), 

-		     RGB(rgba[i][RCOMP], rgba[i][GCOMP], 

-			 rgba[i][BCOMP]));

-}

-

-

-

-/*

- * Write an array of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_pixels_front(struct gl_context *ctx, 

-                                         struct gl_renderbuffer *rb,

-                                         GLuint n,

-                                         const GLint x[], const GLint y[],

-                                         const void *value,

-                                         const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    GLuint i;

-    WMesaContext pwc = wmesa_context(ctx);

-    COLORREF colorref;

-    (void) ctx;

-    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), colorref);

-}

-

-/* Read a horizontal span of color pixels. */

-static void read_rgba_span_front(struct gl_context *ctx, 

-                                 struct gl_renderbuffer *rb,

-                                 GLuint n, GLint x, GLint y,

-                                 void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    WMesaContext pwc = wmesa_context(ctx);

-    GLuint i;

-    COLORREF Color;

-    y = FLIP(y);

-    for (i=0; i<n; i++) {

-	Color = GetPixel(pwc->hDC, x+i, y);

-	rgba[i][RCOMP] = GetRValue(Color);

-	rgba[i][GCOMP] = GetGValue(Color);

-	rgba[i][BCOMP] = GetBValue(Color);

-	rgba[i][ACOMP] = 255;

-    }

-}

-

-

-/* Read an array of color pixels. */

-static void read_rgba_pixels_front(struct gl_context *ctx, 

-                                   struct gl_renderbuffer *rb,

-                                   GLuint n, const GLint x[], const GLint y[],

-                                   void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    WMesaContext pwc = wmesa_context(ctx);

-    GLuint i;

-    COLORREF Color;

-    for (i=0; i<n; i++) {

-        GLint y2 = FLIP(y[i]);

-        Color = GetPixel(pwc->hDC, x[i], y2);

-        rgba[i][RCOMP] = GetRValue(Color);

-        rgba[i][GCOMP] = GetGValue(Color);

-        rgba[i][BCOMP] = GetBValue(Color);

-        rgba[i][ACOMP] = 255;

-    }

-}

-

-/*********************************************************************/

-

-/* DOUBLE BUFFER 32-bit */

-

-#define WMSETPIXEL32(pwc, y, x, r, g, b) { \

-LPDWORD lpdw = ((LPDWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \

-*lpdw = BGR32((r),(g),(b)); }

-

-

-

-/* Write a horizontal span of RGBA color pixels with a boolean mask. */

-static void write_rgba_span_32(struct gl_context *ctx, 

-			       struct gl_renderbuffer *rb, 

-			       GLuint n, GLint x, GLint y,

-			       const void *values, 

-			       const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPDWORD lpdw;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpdw[i] = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 

-				rgba[i][BCOMP]);

-    }

-    else {

-	for (i=0; i<n; i++)

-                *lpdw++ = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 

-				rgba[i][BCOMP]);

-    }

-}

-

-

-/* Write a horizontal span of RGB color pixels with a boolean mask. */

-static void write_rgb_span_32(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb, 

-			      GLuint n, GLint x, GLint y,

-			      const void *values, 

-			      const GLubyte *mask)

-{

-    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPDWORD lpdw;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpdw[i] = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 

-				rgb[i][BCOMP]);

-    }

-    else {

-	for (i=0; i<n; i++)

-                *lpdw++ = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 

-				rgb[i][BCOMP]);

-    }

-}

-

-/*

- * Write a horizontal span of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_span_32(struct gl_context *ctx, 

-				    struct gl_renderbuffer *rb,

-				    GLuint n, GLint x, GLint y,

-				    const void *value, 

-				    const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    LPDWORD lpdw;

-    DWORD pixel;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    y=FLIP(y);

-    pixel = BGR32(color[RCOMP], color[GCOMP], color[BCOMP]);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpdw[i] = pixel;

-    }

-    else

-	for (i=0; i<n; i++)

-                *lpdw++ = pixel;

-

-}

-

-/* Write an array of RGBA pixels with a boolean mask. */

-static void write_rgba_pixels_32(struct gl_context *ctx, 

-				 struct gl_renderbuffer *rb,

-				 GLuint n, const GLint x[], const GLint y[],

-				 const void *values, 

-				 const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL32(pwfb, FLIP(y[i]), x[i],

-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

-}

-

-/*

- * Write an array of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_pixels_32(struct gl_context *ctx, 

-				      struct gl_renderbuffer *rb,

-				      GLuint n,

-				      const GLint x[], const GLint y[],

-				      const void *value,

-				      const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL32(pwfb, FLIP(y[i]),x[i],color[RCOMP],

-			 color[GCOMP], color[BCOMP]);

-}

-

-/* Read a horizontal span of color pixels. */

-static void read_rgba_span_32(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb,

-			      GLuint n, GLint x, GLint y,

-			      void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i;

-    DWORD pixel;

-    LPDWORD lpdw;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    

-    y = FLIP(y);

-    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    for (i=0; i<n; i++) {

-	pixel = lpdw[i];

-	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);

-	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);

-	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);

-	rgba[i][ACOMP] = 255;

-    }

-}

-

-

-/* Read an array of color pixels. */

-static void read_rgba_pixels_32(struct gl_context *ctx, 

-				struct gl_renderbuffer *rb,

-				GLuint n, const GLint x[], const GLint y[],

-				void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i;

-    DWORD pixel;

-    LPDWORD lpdw;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-

-    for (i=0; i<n; i++) {

-	GLint y2 = FLIP(y[i]);

-	lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];

-	pixel = *lpdw;

-	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);

-	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);

-	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);

-	rgba[i][ACOMP] = 255;

-  }

-}

-

-

-/*********************************************************************/

-

-/* DOUBLE BUFFER 24-bit */

-

-#define WMSETPIXEL24(pwc, y, x, r, g, b) { \

-LPBYTE lpb = ((LPBYTE)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (3 * x)); \

-lpb[0] = (b); \

-lpb[1] = (g); \

-lpb[2] = (r); }

-

-/* Write a horizontal span of RGBA color pixels with a boolean mask. */

-static void write_rgba_span_24(struct gl_context *ctx, 

-			       struct gl_renderbuffer *rb, 

-			       GLuint n, GLint x, GLint y,

-			       const void *values, 

-			       const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPBYTE lpb;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i]) {

-                lpb[3*i] = rgba[i][BCOMP];

-                lpb[3*i+1] = rgba[i][GCOMP];

-                lpb[3*i+2] = rgba[i][RCOMP];

-	    }

-    }

-    else {

-	    for (i=0; i<n; i++) {

-            *lpb++ = rgba[i][BCOMP];

-            *lpb++ = rgba[i][GCOMP];

-            *lpb++ = rgba[i][RCOMP];

-	    }

-    }

-}

-

-

-/* Write a horizontal span of RGB color pixels with a boolean mask. */

-static void write_rgb_span_24(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb, 

-			      GLuint n, GLint x, GLint y,

-			      const void *values, 

-			      const GLubyte *mask)

-{

-    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPBYTE lpb;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i]) {

-            lpb[3*i] = rgb[i][BCOMP];

-            lpb[3*i+1] = rgb[i][GCOMP];

-            lpb[3*i+2] = rgb[i][RCOMP];

-	    }

-    }

-    else {

-    	for (i=0; i<n; i++) {

-    		*lpb++ = rgb[i][BCOMP];

-    		*lpb++ = rgb[i][GCOMP];

-    		*lpb++ = rgb[i][RCOMP];

-    	}

-    }

-}

-

-/*

- * Write a horizontal span of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_span_24(struct gl_context *ctx, 

-				    struct gl_renderbuffer *rb,

-				    GLuint n, GLint x, GLint y,

-				    const void *value, 

-				    const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    LPBYTE lpb;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

-    y=FLIP(y);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i]) {

-	    	lpb[3*i] = color[BCOMP];

-	    	lpb[3*i+1] = color[GCOMP];

-	    	lpb[3*i+2] = color[RCOMP];

-	    }

-    }

-    else

-	for (i=0; i<n; i++) {

-		*lpb++ = color[BCOMP];

-		*lpb++ = color[GCOMP];

-		*lpb++ = color[RCOMP];		

-	}

-}

-

-/* Write an array of RGBA pixels with a boolean mask. */

-static void write_rgba_pixels_24(struct gl_context *ctx, 

-				 struct gl_renderbuffer *rb,

-				 GLuint n, const GLint x[], const GLint y[],

-				 const void *values, 

-				 const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL24(pwfb, FLIP(y[i]), x[i],

-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

-}

-

-/*

- * Write an array of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_pixels_24(struct gl_context *ctx, 

-				      struct gl_renderbuffer *rb,

-				      GLuint n,

-				      const GLint x[], const GLint y[],

-				      const void *value,

-				      const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL24(pwfb, FLIP(y[i]),x[i],color[RCOMP],

-			 color[GCOMP], color[BCOMP]);

-}

-

-/* Read a horizontal span of color pixels. */

-static void read_rgba_span_24(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb,

-			      GLuint n, GLint x, GLint y,

-			      void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i;

-    LPBYTE lpb;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    

-    y = FLIP(y);

-    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);

-    for (i=0; i<n; i++) {

-	rgba[i][RCOMP] = lpb[3*i+2];

-	rgba[i][GCOMP] = lpb[3*i+1];

-	rgba[i][BCOMP] = lpb[3*i];

-	rgba[i][ACOMP] = 255;

-    }

-}

-

-

-/* Read an array of color pixels. */

-static void read_rgba_pixels_24(struct gl_context *ctx, 

-				struct gl_renderbuffer *rb,

-				GLuint n, const GLint x[], const GLint y[],

-				void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i;

-    LPBYTE lpb;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-

-    for (i=0; i<n; i++) {

-	GLint y2 = FLIP(y[i]);

-	lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + (3 * x[i]);

-	rgba[i][RCOMP] = lpb[3*i+2];

-	rgba[i][GCOMP] = lpb[3*i+1];

-	rgba[i][BCOMP] = lpb[3*i];

-	rgba[i][ACOMP] = 255;

-  }

-}

-

-

-/*********************************************************************/

-

-/* DOUBLE BUFFER 16-bit */

-

-#define WMSETPIXEL16(pwc, y, x, r, g, b) { \

-LPWORD lpw = ((LPWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \

-*lpw = BGR16((r),(g),(b)); }

-

-

-

-/* Write a horizontal span of RGBA color pixels with a boolean mask. */

-static void write_rgba_span_16(struct gl_context *ctx, 

-			       struct gl_renderbuffer *rb, 

-			       GLuint n, GLint x, GLint y,

-			       const void *values, 

-			       const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPWORD lpw;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpw[i] = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 

-			       rgba[i][BCOMP]);

-    }

-    else {

-	for (i=0; i<n; i++)

-                *lpw++ = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 

-			       rgba[i][BCOMP]);

-    }

-}

-

-

-/* Write a horizontal span of RGB color pixels with a boolean mask. */

-static void write_rgb_span_16(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb, 

-			      GLuint n, GLint x, GLint y,

-			      const void *values, 

-			      const GLubyte *mask)

-{

-    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    GLuint i;

-    LPWORD lpw;

-

-    (void) ctx;

-    

-    y=FLIP(y);

-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpw[i] = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 

-			       rgb[i][BCOMP]);

-    }

-    else {

-	for (i=0; i<n; i++)

-                *lpw++ = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 

-			       rgb[i][BCOMP]);

-    }

-}

-

-/*

- * Write a horizontal span of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_span_16(struct gl_context *ctx, 

-				    struct gl_renderbuffer *rb,

-				    GLuint n, GLint x, GLint y,

-				    const void *value, 

-				    const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    LPWORD lpw;

-    WORD pixel;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    (void) ctx;

-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    y=FLIP(y);

-    pixel = BGR16(color[RCOMP], color[GCOMP], color[BCOMP]);

-    if (mask) {

-	for (i=0; i<n; i++)

-	    if (mask[i])

-                lpw[i] = pixel;

-    }

-    else

-	for (i=0; i<n; i++)

-                *lpw++ = pixel;

-

-}

-

-/* Write an array of RGBA pixels with a boolean mask. */

-static void write_rgba_pixels_16(struct gl_context *ctx, 

-				 struct gl_renderbuffer *rb,

-				 GLuint n, const GLint x[], const GLint y[],

-				 const void *values, 

-				 const GLubyte *mask)

-{

-    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    (void) ctx;

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL16(pwfb, FLIP(y[i]), x[i],

-			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);

-}

-

-/*

- * Write an array of pixels with a boolean mask.  The current color

- * is used for all pixels.

- */

-static void write_mono_rgba_pixels_16(struct gl_context *ctx, 

-				      struct gl_renderbuffer *rb,

-				      GLuint n,

-				      const GLint x[], const GLint y[],

-				      const void *value,

-				      const GLubyte *mask)

-{

-    const GLchan *color = (const GLchan *)value;

-    GLuint i;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    (void) ctx;

-    for (i=0; i<n; i++)

-	if (mask[i])

-	    WMSETPIXEL16(pwfb, FLIP(y[i]),x[i],color[RCOMP],

-			 color[GCOMP], color[BCOMP]);

-}

-

-/* Read a horizontal span of color pixels. */

-static void read_rgba_span_16(struct gl_context *ctx, 

-			      struct gl_renderbuffer *rb,

-			      GLuint n, GLint x, GLint y,

-			      void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i, pixel;

-    LPWORD lpw;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-    

-    y = FLIP(y);

-    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;

-    for (i=0; i<n; i++) {

-	pixel = lpw[i];

-	/* Windows uses 5,5,5 for 16-bit */

-	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;

-	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;

-	rgba[i][BCOMP] = (pixel & 0x001f) << 3;

-	rgba[i][ACOMP] = 255;

-    }

-}

-

-

-/* Read an array of color pixels. */

-static void read_rgba_pixels_16(struct gl_context *ctx, 

-				struct gl_renderbuffer *rb,

-				GLuint n, const GLint x[], const GLint y[],

-				void *values)

-{

-    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;

-    GLuint i, pixel;

-    LPWORD lpw;

-    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);

-

-    for (i=0; i<n; i++) {

-	GLint y2 = FLIP(y[i]);

-	lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];

-	pixel = *lpw;

-	/* Windows uses 5,5,5 for 16-bit */

-	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;

-	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;

-	rgba[i][BCOMP] = (pixel & 0x001f) << 3;

-	rgba[i][ACOMP] = 255;

-  }

-}

-

-

-

-

-/**********************************************************************/

-/*****                   BUFFER Functions                         *****/

-/**********************************************************************/

-

-

-

-

-static void

-wmesa_delete_renderbuffer(struct gl_renderbuffer *rb)

-{

-    free(rb);

-}

-

-

-/**

- * This is called by Mesa whenever it determines that the window size

- * has changed.  Do whatever's needed to cope with that.

- */

-static GLboolean

-wmesa_renderbuffer_storage(struct gl_context *ctx, 

-			   struct gl_renderbuffer *rb,

-			   GLenum internalFormat, 

-			   GLuint width, 

-			   GLuint height)

-{

-    rb->Width = width;

-    rb->Height = height;

-    return GL_TRUE;

-}

-

-

-/**

- * Plug in the Get/PutRow/Values functions for a renderbuffer depending

- * on if we're drawing to the front or back color buffer.

- */

-static void

-wmesa_set_renderbuffer_funcs(struct gl_renderbuffer *rb, int pixelformat,

-                             int cColorBits, int double_buffer)

-{

-    if (double_buffer) {

-        /* back buffer */

-	/* Picking the correct span functions is important because

-	 * the DIB was allocated with the indicated depth. */

-	switch(pixelformat) {

-	case PF_5R6G5B:

-	    rb->PutRow = write_rgba_span_16;

-	    rb->PutRowRGB = write_rgb_span_16;

-	    rb->PutMonoRow = write_mono_rgba_span_16;

-	    rb->PutValues = write_rgba_pixels_16;

-	    rb->PutMonoValues = write_mono_rgba_pixels_16;

-	    rb->GetRow = read_rgba_span_16;

-	    rb->GetValues = read_rgba_pixels_16;

-	    break;

-	case PF_8R8G8B:

-		if (cColorBits == 24)

-		{

-		    rb->PutRow = write_rgba_span_24;

-		    rb->PutRowRGB = write_rgb_span_24;

-		    rb->PutMonoRow = write_mono_rgba_span_24;

-		    rb->PutValues = write_rgba_pixels_24;

-		    rb->PutMonoValues = write_mono_rgba_pixels_24;

-		    rb->GetRow = read_rgba_span_24;

-		    rb->GetValues = read_rgba_pixels_24;

-		}

-		else

-		{

-	        rb->PutRow = write_rgba_span_32;

-	        rb->PutRowRGB = write_rgb_span_32;

-	        rb->PutMonoRow = write_mono_rgba_span_32;

-	        rb->PutValues = write_rgba_pixels_32;

-	        rb->PutMonoValues = write_mono_rgba_pixels_32;

-	        rb->GetRow = read_rgba_span_32;

-	        rb->GetValues = read_rgba_pixels_32;

-		}

-	    break;

-	default:

-	    break;

-	}

-    }

-    else {

-        /* front buffer (actual Windows window) */

-	rb->PutRow = write_rgba_span_front;

-	rb->PutRowRGB = write_rgb_span_front;

-	rb->PutMonoRow = write_mono_rgba_span_front;

-	rb->PutValues = write_rgba_pixels_front;

-	rb->PutMonoValues = write_mono_rgba_pixels_front;

-	rb->GetRow = read_rgba_span_front;

-	rb->GetValues = read_rgba_pixels_front;

-    }

-}

-

-/**

- * Called by ctx->Driver.ResizeBuffers()

- * Resize the front/back colorbuffers to match the latest window size.

- */

-static void

-wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer,

-                     GLuint width, GLuint height)

-{

-    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);

-

-    if (pwfb->Base.Width != width || pwfb->Base.Height != height) {

-	/* Realloc back buffer */

-	if (ctx->Visual.doubleBufferMode == 1) {

-	    wmDeleteBackingStore(pwfb);

-	    wmCreateBackingStore(pwfb, width, height);

-	}

-    }

-    _mesa_resize_framebuffer(ctx, buffer, width, height);

-}

-

-

-/**

- * Called by glViewport.

- * This is a good time for us to poll the current window size and adjust

- * our renderbuffers to match the current window size.

- * Remember, we have no opportunity to respond to conventional

- * resize events since the driver has no event loop.

- * Thus, we poll.

- * MakeCurrent also ends up making a call here, so that ensures

- * we get the viewport set correctly, even if the app does not call

- * glViewport and relies on the defaults.

- */

-static void wmesa_viewport(struct gl_context *ctx, 

-			   GLint x, GLint y, 

-			   GLsizei width, GLsizei height)

-{

-    GLuint new_width, new_height;

-

-    wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height);

-

-    /**

-     * Resize buffers if the window size changed.

-     */

-    wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height);

-    ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */

-}

-

-

-

-

-/**

- * Called when the driver should update it's state, based on the new_state

- * flags.

- */

-static void wmesa_update_state(struct gl_context *ctx, GLuint new_state)

-{

-    _swrast_InvalidateState(ctx, new_state);

-    _swsetup_InvalidateState(ctx, new_state);

-    _vbo_InvalidateState(ctx, new_state);

-    _tnl_InvalidateState(ctx, new_state);

-

-    /* TODO - This code is not complete yet because I 

-     * don't know what to do for all state updates.

-     */

-

-    if (new_state & _NEW_BUFFERS) {

-    }

-}

-

-

-

-

-

-/**********************************************************************/

-/*****                   WMESA Functions                          *****/

-/**********************************************************************/

-

-WMesaContext WMesaCreateContext(HDC hDC, 

-				HPALETTE* Pal,

-				GLboolean rgb_flag,

-				GLboolean db_flag,

-				GLboolean alpha_flag)

-{

-    WMesaContext c;

-    struct dd_function_table functions;

-    GLint red_bits, green_bits, blue_bits, alpha_bits;

-    struct gl_context *ctx;

-    struct gl_config *visual;

-

-    (void) Pal;

-    

-    /* Indexed mode not supported */

-    if (!rgb_flag)

-	return NULL;

-

-    /* Allocate wmesa context */

-    c = CALLOC_STRUCT(wmesa_context);

-    if (!c)

-	return NULL;

-

-#if 0

-    /* I do not understand this contributed code */

-    /* Support memory and device contexts */

-    if(WindowFromDC(hDC) != NULL) {

-	c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */

-    }

-    else {

-	c->hDC = hDC;

-    }

-#else

-    c->hDC = hDC;

-#endif

-

-    /* Get data for visual */

-    /* Dealing with this is actually a bit of overkill because Mesa will end

-     * up treating all color component size requests less than 8 by using 

-     * a single byte per channel.  In addition, the interface to the span

-     * routines passes colors as an entire byte per channel anyway, so there

-     * is nothing to be saved by telling the visual to be 16 bits if the device

-     * is 16 bits.  That is, Mesa is going to compute colors down to 8 bits per

-     * channel anyway.

-     * But we go through the motions here anyway.

-     */

-    switch (GetDeviceCaps(c->hDC, BITSPIXEL)) {

-    case 16:

-	red_bits = green_bits = blue_bits = 5;

-	alpha_bits = 0;

-	break;

-    default:

-	red_bits = green_bits = blue_bits = 8;

-	alpha_bits = 8;

-	break;

-    }

-    /* Create visual based on flags */

-    visual = _mesa_create_visual(db_flag,    /* db_flag */

-                                 GL_FALSE,   /* stereo */

-                                 red_bits, green_bits, blue_bits, /* color RGB */

-                                 alpha_flag ? alpha_bits : 0, /* color A */

-                                 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */

-                                 8,          /* stencil_bits */

-                                 16,16,16,   /* accum RGB */

-                                 alpha_flag ? 16 : 0, /* accum A */

-                                 1);         /* num samples */

-    

-    if (!visual) {

-	free(c);

-	return NULL;

-    }

-

-    /* Set up driver functions */

-    _mesa_init_driver_functions(&functions);

-    functions.GetString = wmesa_get_string;

-    functions.UpdateState = wmesa_update_state;

-    functions.GetBufferSize = wmesa_get_buffer_size;

-    functions.Flush = wmesa_flush;

-    functions.Clear = clear;

-    functions.ClearColor = clear_color;

-    functions.ResizeBuffers = wmesa_resize_buffers;

-    functions.Viewport = wmesa_viewport;

-

-    /* initialize the Mesa context data */

-    ctx = &c->gl_ctx;

-    _mesa_initialize_context(ctx, API_OPENGL, visual,

-                             NULL, &functions, (void *)c);

-

-    /* visual no longer needed - it was copied by _mesa_initialize_context() */

-    _mesa_destroy_visual(visual);

-

-    _mesa_enable_sw_extensions(ctx);

-    _mesa_enable_1_3_extensions(ctx);

-    _mesa_enable_1_4_extensions(ctx);

-    _mesa_enable_1_5_extensions(ctx);

-    _mesa_enable_2_0_extensions(ctx);

-    _mesa_enable_2_1_extensions(ctx);

-  

-    _mesa_meta_init(ctx);

-

-    /* Initialize the software rasterizer and helper modules. */

-    if (!_swrast_CreateContext(ctx) ||

-        !_vbo_CreateContext(ctx) ||

-        !_tnl_CreateContext(ctx) ||

-	!_swsetup_CreateContext(ctx)) {

-	_mesa_free_context_data(ctx);

-	free(c);

-	return NULL;

-    }

-    _swsetup_Wakeup(ctx);

-    TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;

-

-    return c;

-}

-

-

-void WMesaDestroyContext( WMesaContext pwc )

-{

-    struct gl_context *ctx = &pwc->gl_ctx;

-    WMesaFramebuffer pwfb;

-    GET_CURRENT_CONTEXT(cur_ctx);

-

-    if (cur_ctx == ctx) {

-        /* unbind current if deleting current context */

-        WMesaMakeCurrent(NULL, NULL);

-    }

-

-    /* clean up frame buffer resources */

-    pwfb = wmesa_lookup_framebuffer(pwc->hDC);

-    if (pwfb) {

-	if (ctx->Visual.doubleBufferMode == 1)

-	    wmDeleteBackingStore(pwfb);

-	wmesa_free_framebuffer(pwc->hDC);

-    }

-

-    /* Release for device, not memory contexts */

-    if (WindowFromDC(pwc->hDC) != NULL)

-    {

-      ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);

-    }

-    DeleteObject(pwc->clearPen); 

-    DeleteObject(pwc->clearBrush); 

-    

-    _mesa_meta_free(ctx);

-

-    _swsetup_DestroyContext(ctx);

-    _tnl_DestroyContext(ctx);

-    _vbo_DestroyContext(ctx);

-    _swrast_DestroyContext(ctx);

-    

-    _mesa_free_context_data(ctx);

-    free(pwc);

-}

-

-

-/**

- * Create a new color renderbuffer.

- */

-static struct gl_renderbuffer *

-wmesa_new_renderbuffer(void)

-{

-    struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer);

-    if (!rb)

-        return NULL;

-

-    _mesa_init_renderbuffer(rb, (GLuint)0);

-    

-    rb->_BaseFormat = GL_RGBA;

-    rb->InternalFormat = GL_RGBA;

-    rb->DataType = CHAN_TYPE;

-    rb->Delete = wmesa_delete_renderbuffer;

-    rb->AllocStorage = wmesa_renderbuffer_storage;

-    return rb;

-}

-

-

-void WMesaMakeCurrent(WMesaContext c, HDC hdc)

-{

-    WMesaFramebuffer pwfb;

-

-    {

-        /* return if already current */

-        GET_CURRENT_CONTEXT(ctx);

-        WMesaContext pwc = wmesa_context(ctx);

-        if (pwc && c == pwc && pwc->hDC == hdc)

-            return;

-    }

-

-    pwfb = wmesa_lookup_framebuffer(hdc);

-

-    /* Lazy creation of framebuffers */

-    if (c && !pwfb && hdc) {

-        struct gl_renderbuffer *rb;

-        struct gl_config *visual = &c->gl_ctx.Visual;

-        GLuint width, height;

-

-        get_window_size(hdc, &width, &height);

-

-	c->clearPen = CreatePen(PS_SOLID, 1, 0); 

-	c->clearBrush = CreateSolidBrush(0); 

-

-        pwfb = wmesa_new_framebuffer(hdc, visual);

-

-	/* Create back buffer if double buffered */

-	if (visual->doubleBufferMode == 1) {

-	    wmCreateBackingStore(pwfb, width, height);

-	}

-	

-        /* make render buffers */

-        if (visual->doubleBufferMode == 1) {

-            rb = wmesa_new_renderbuffer();

-            _mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb);

-            wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 1);

-	}

-        rb = wmesa_new_renderbuffer();

-        _mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb);

-        wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 0);

-

-	/* Let Mesa own the Depth, Stencil, and Accum buffers */

-        _mesa_add_soft_renderbuffers(&pwfb->Base,

-                                     GL_FALSE, /* color */

-                                     visual->depthBits > 0,

-                                     visual->stencilBits > 0,

-                                     visual->accumRedBits > 0,

-                                     visual->alphaBits >0, 

-                                     GL_FALSE);

-    }

-

-    if (c && pwfb)

-	_mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base);

-    else

-        _mesa_make_current(NULL, NULL, NULL);

-}

-

-

-void WMesaSwapBuffers( HDC hdc )

-{

-    GET_CURRENT_CONTEXT(ctx);

-    WMesaContext pwc = wmesa_context(ctx);

-    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);

-

-    if (!pwfb) {

-        _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");

-        return;

-    }

-

-    /* If we're swapping the buffer associated with the current context

-     * we have to flush any pending rendering commands first.

-     */

-    if (pwc->hDC == hdc) {

-	_mesa_notifySwapBuffers(ctx);

-

-	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,

-	       pwfb->dib_hDC, 0, 0, SRCCOPY);

-    }

-    else {

-        /* XXX for now only allow swapping current window */

-        _mesa_problem(NULL, "wmesa: can't swap non-current window");

-    }

-}

-

-void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx)

-{

-	_mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);	

-}

-

+/*
+ * Windows (Win32/Win64) device driver for Mesa
+ *
+ */
+
+#include "wmesadef.h"
+#include "colors.h"
+#include "GL/wmesa.h"
+#include <winuser.h>
+#include "main/context.h"
+#include "main/extensions.h"
+#include "main/framebuffer.h"
+#include "main/renderbuffer.h"
+#include "main/macros.h"
+#include "drivers/common/driverfuncs.h"
+#include "drivers/common/meta.h"
+#include "vbo/vbo.h"
+#include "swrast/swrast.h"
+#include "swrast_setup/swrast_setup.h"
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
+
+
+/* linked list of our Framebuffers (windows) */
+static WMesaFramebuffer FirstFramebuffer = NULL;
+
+
+/**
+ * Create a new WMesaFramebuffer object which will correspond to the
+ * given HDC (Window handle).
+ */
+static WMesaFramebuffer
+wmesa_new_framebuffer(HDC hdc, struct gl_config *visual)
+{
+    WMesaFramebuffer pwfb
+        = (WMesaFramebuffer) malloc(sizeof(struct wmesa_framebuffer));
+    if (pwfb) {
+        _mesa_initialize_window_framebuffer(&pwfb->Base, visual);
+        pwfb->hDC = hdc;
+        /* insert at head of list */
+        pwfb->next = FirstFramebuffer;
+        FirstFramebuffer = pwfb;
+    }
+    return pwfb;
+}
+
+/**
+ * Given an hdc, free the corresponding WMesaFramebuffer
+ */
+static void
+wmesa_free_framebuffer(HDC hdc)
+{
+    WMesaFramebuffer pwfb, prev;
+    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
+        if (pwfb->hDC == hdc)
+            break;
+	prev = pwfb;
+    }
+    if (pwfb) {
+        struct gl_framebuffer *fb;
+	if (pwfb == FirstFramebuffer)
+	    FirstFramebuffer = pwfb->next;
+	else
+	    prev->next = pwfb->next;
+        fb = &pwfb->Base;
+        _mesa_reference_framebuffer(&fb, NULL); 
+    }
+}
+
+/**
+ * Given an hdc, return the corresponding WMesaFramebuffer
+ */
+static WMesaFramebuffer
+wmesa_lookup_framebuffer(HDC hdc)
+{
+    WMesaFramebuffer pwfb;
+    for (pwfb = FirstFramebuffer; pwfb; pwfb = pwfb->next) {
+        if (pwfb->hDC == hdc)
+            return pwfb;
+    }
+    return NULL;
+}
+
+
+/**
+ * Given a struct gl_framebuffer, return the corresponding WMesaFramebuffer.
+ */
+static WMesaFramebuffer wmesa_framebuffer(struct gl_framebuffer *fb)
+{
+    return (WMesaFramebuffer) fb;
+}
+
+
+/**
+ * Given a struct gl_context, return the corresponding WMesaContext.
+ */
+static WMesaContext wmesa_context(const struct gl_context *ctx)
+{
+    return (WMesaContext) ctx;
+}
+
+
+/*
+ * Every driver should implement a GetString function in order to
+ * return a meaningful GL_RENDERER string.
+ */
+static const GLubyte *wmesa_get_string(struct gl_context *ctx, GLenum name)
+{
+    return (name == GL_RENDERER) ? 
+	(GLubyte *) "Mesa Windows GDI Driver" : NULL;
+}
+
+
+/*
+ * Determine the pixel format based on the pixel size.
+ */
+static void wmSetPixelFormat(WMesaFramebuffer pwfb, HDC hDC)
+{
+    pwfb->cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
+
+    /* Only 16 and 32 bit targets are supported now */
+    assert(pwfb->cColorBits == 0 ||
+	   pwfb->cColorBits == 16 || 
+	   pwfb->cColorBits == 24 || 
+	   pwfb->cColorBits == 32);
+
+    switch(pwfb->cColorBits){
+    case 8:
+	pwfb->pixelformat = PF_INDEX8;
+	break;
+    case 16:
+	pwfb->pixelformat = PF_5R6G5B;
+	break;
+    case 24:
+    case 32:
+	pwfb->pixelformat = PF_8R8G8B;
+	break;
+    default:
+	pwfb->pixelformat = PF_BADFORMAT;
+    }
+}
+
+
+/**
+ * Create DIB for back buffer.
+ * We write into this memory with the span routines and then blit it
+ * to the window on a buffer swap.
+ */
+static BOOL wmCreateBackingStore(WMesaFramebuffer pwfb, long lxSize, long lySize)
+{
+    LPBITMAPINFO pbmi = &(pwfb->bmi);
+    HDC          hic;
+
+    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+    pbmi->bmiHeader.biWidth = lxSize;
+    pbmi->bmiHeader.biHeight= -lySize;
+    pbmi->bmiHeader.biPlanes = 1;
+    pbmi->bmiHeader.biBitCount = GetDeviceCaps(pwfb->hDC, BITSPIXEL);
+    pbmi->bmiHeader.biCompression = BI_RGB;
+    pbmi->bmiHeader.biSizeImage = 0;
+    pbmi->bmiHeader.biXPelsPerMeter = 0;
+    pbmi->bmiHeader.biYPelsPerMeter = 0;
+    pbmi->bmiHeader.biClrUsed = 0;
+    pbmi->bmiHeader.biClrImportant = 0;
+    
+    pwfb->cColorBits = pbmi->bmiHeader.biBitCount;
+    pwfb->ScanWidth = (lxSize * (pwfb->cColorBits / 8) + 3) & ~3;
+    
+    hic = CreateIC("display", NULL, NULL, NULL);
+    pwfb->dib_hDC = CreateCompatibleDC(hic);
+    
+    pwfb->hbmDIB = CreateDIBSection(hic,
+				   &pwfb->bmi,
+				   DIB_RGB_COLORS,
+				   (void **)&(pwfb->pbPixels),
+				   0,
+				   0);
+    pwfb->hOldBitmap = SelectObject(pwfb->dib_hDC, pwfb->hbmDIB);
+    
+    DeleteDC(hic);
+
+    wmSetPixelFormat(pwfb, pwfb->hDC);
+    return TRUE;
+}
+
+
+static void wmDeleteBackingStore(WMesaFramebuffer pwfb)
+{
+    if (pwfb->hbmDIB) {
+	SelectObject(pwfb->dib_hDC, pwfb->hOldBitmap);
+	DeleteDC(pwfb->dib_hDC);
+	DeleteObject(pwfb->hbmDIB);
+    }
+}
+
+
+/**
+ * Find the width and height of the window named by hdc.
+ */
+static void
+get_window_size(HDC hdc, GLuint *width, GLuint *height)
+{
+    if (WindowFromDC(hdc)) {
+        RECT rect;
+        GetClientRect(WindowFromDC(hdc), &rect);
+        *width = rect.right - rect.left;
+        *height = rect.bottom - rect.top;
+    }
+    else { /* Memory context */
+        /* From contributed code - use the size of the desktop
+         * for the size of a memory context (?) */
+        *width = GetDeviceCaps(hdc, HORZRES);
+        *height = GetDeviceCaps(hdc, VERTRES);
+    }
+}
+
+
+static void
+wmesa_get_buffer_size(struct gl_framebuffer *buffer, GLuint *width, GLuint *height)
+{
+    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
+    get_window_size(pwfb->hDC, width, height);
+}
+
+
+static void wmesa_flush(struct gl_context *ctx)
+{
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->WinSysDrawBuffer);
+
+    if (ctx->Visual.doubleBufferMode == 1) {
+	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
+	       pwfb->dib_hDC, 0, 0, SRCCOPY);
+    }
+    else {
+	/* Do nothing for single buffer */
+    }
+}
+
+
+/**********************************************************************/
+/*****                   CLEAR Functions                          *****/
+/**********************************************************************/
+
+/* If we do not implement these, Mesa clears the buffers via the pixel
+ * span writing interface, which is very slow for a clear operation.
+ */
+
+/*
+ * Set the color used to clear the color buffer.
+ */
+static void clear_color(struct gl_context *ctx, const GLfloat color[4])
+{
+    WMesaContext pwc = wmesa_context(ctx);
+    GLubyte col[3];
+
+    CLAMPED_FLOAT_TO_UBYTE(col[0], color[0]);
+    CLAMPED_FLOAT_TO_UBYTE(col[1], color[1]);
+    CLAMPED_FLOAT_TO_UBYTE(col[2], color[2]);
+    pwc->clearColorRef = RGB(col[0], col[1], col[2]);
+    DeleteObject(pwc->clearPen);
+    DeleteObject(pwc->clearBrush);
+    pwc->clearPen = CreatePen(PS_SOLID, 1, pwc->clearColorRef); 
+    pwc->clearBrush = CreateSolidBrush(pwc->clearColorRef); 
+}
+
+
+/* 
+ * Clear the specified region of the color buffer using the clear color 
+ * or index as specified by one of the two functions above. 
+ * 
+ * This procedure clears either the front and/or the back COLOR buffers. 
+ * Only the "left" buffer is cleared since we are not stereo. 
+ * Clearing of the other non-color buffers is left to the swrast. 
+ */ 
+
+static void clear(struct gl_context *ctx, GLbitfield mask)
+{
+#define FLIP(Y)  (ctx->DrawBuffer->Height - (Y) - 1)
+    const GLint x = ctx->DrawBuffer->_Xmin;
+    const GLint y = ctx->DrawBuffer->_Ymin;
+    const GLint height = ctx->DrawBuffer->_Ymax - ctx->DrawBuffer->_Ymin;
+    const GLint width  = ctx->DrawBuffer->_Xmax - ctx->DrawBuffer->_Xmin;
+
+    WMesaContext pwc = wmesa_context(ctx);
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    int done = 0;
+
+    /* Let swrast do all the work if the masks are not set to
+     * clear all channels. */
+    if (!ctx->Color.ColorMask[0][0] ||
+	!ctx->Color.ColorMask[0][1] ||
+	!ctx->Color.ColorMask[0][2] ||
+	!ctx->Color.ColorMask[0][3]) {
+	_swrast_Clear(ctx, mask);
+	return;
+    }
+
+    /* Back buffer */
+    if (mask & BUFFER_BIT_BACK_LEFT) { 
+	
+	int     i, rowSize; 
+	UINT    bytesPerPixel = pwfb->cColorBits / 8; 
+	LPBYTE  lpb, clearRow;
+	LPWORD  lpw;
+	BYTE    bColor; 
+	WORD    wColor; 
+	BYTE    r, g, b; 
+	DWORD   dwColor; 
+	LPDWORD lpdw; 
+	
+	/* Try for a fast clear - clearing entire buffer with a single
+	 * byte value. */
+	if (width == ctx->DrawBuffer->Width &&
+            height == ctx->DrawBuffer->Height) { /* entire buffer */
+	    /* Now check for an easy clear value */
+	    switch (bytesPerPixel) {
+	    case 1:
+		bColor = BGR8(GetRValue(pwc->clearColorRef), 
+			      GetGValue(pwc->clearColorRef), 
+			      GetBValue(pwc->clearColorRef));
+		memset(pwfb->pbPixels, bColor, 
+		       pwfb->ScanWidth * height);
+		done = 1;
+		break;
+	    case 2:
+		wColor = BGR16(GetRValue(pwc->clearColorRef), 
+			       GetGValue(pwc->clearColorRef), 
+			       GetBValue(pwc->clearColorRef)); 
+		if (((wColor >> 8) & 0xff) == (wColor & 0xff)) {
+		    memset(pwfb->pbPixels, wColor & 0xff, 
+			   pwfb->ScanWidth * height);
+		    done = 1;
+		}
+		break;
+	    case 3:
+		/* fall through */
+	    case 4:
+		if (GetRValue(pwc->clearColorRef) == 
+		    GetGValue(pwc->clearColorRef) &&
+		    GetRValue(pwc->clearColorRef) == 
+		    GetBValue(pwc->clearColorRef)) {
+		    memset(pwfb->pbPixels, 
+			   GetRValue(pwc->clearColorRef), 
+			   pwfb->ScanWidth * height);
+		    done = 1;
+		}
+		break;
+	    default:
+		break;
+	    }
+	} /* all */
+
+	if (!done) {
+	    /* Need to clear a row at a time.  Begin by setting the first
+	     * row in the area to be cleared to the clear color. */
+	    
+	    clearRow = pwfb->pbPixels + 
+		pwfb->ScanWidth * FLIP(y) +
+		bytesPerPixel * x; 
+	    switch (bytesPerPixel) {
+	    case 1:
+		lpb = clearRow;
+		bColor = BGR8(GetRValue(pwc->clearColorRef), 
+			      GetGValue(pwc->clearColorRef), 
+			      GetBValue(pwc->clearColorRef));
+		memset(lpb, bColor, width);
+		break;
+	    case 2:
+		lpw = (LPWORD)clearRow;
+		wColor = BGR16(GetRValue(pwc->clearColorRef), 
+			       GetGValue(pwc->clearColorRef), 
+			       GetBValue(pwc->clearColorRef)); 
+		for (i=0; i<width; i++)
+		    *lpw++ = wColor;
+		break;
+	    case 3: 
+		lpb = clearRow;
+		r = GetRValue(pwc->clearColorRef); 
+		g = GetGValue(pwc->clearColorRef); 
+		b = GetBValue(pwc->clearColorRef); 
+		for (i=0; i<width; i++) {
+		    *lpb++ = b; 
+		    *lpb++ = g; 
+		    *lpb++ = r; 
+		} 
+		break;
+	    case 4: 
+		lpdw = (LPDWORD)clearRow; 
+		dwColor = BGR32(GetRValue(pwc->clearColorRef), 
+				GetGValue(pwc->clearColorRef), 
+				GetBValue(pwc->clearColorRef)); 
+		for (i=0; i<width; i++)
+		    *lpdw++ = dwColor;
+		break;
+	    default:
+		break;
+	    } /* switch */
+	    
+	    /* copy cleared row to other rows in buffer */
+	    lpb = clearRow - pwfb->ScanWidth;
+	    rowSize = width * bytesPerPixel;
+	    for (i=1; i<height; i++) { 
+		memcpy(lpb, clearRow, rowSize); 
+		lpb -= pwfb->ScanWidth; 
+	    } 
+	} /* not done */
+	mask &= ~BUFFER_BIT_BACK_LEFT;
+    } /* back buffer */ 
+
+    /* front buffer */
+    if (mask & BUFFER_BIT_FRONT_LEFT) { 
+	HDC DC = pwc->hDC; 
+	HPEN Old_Pen = SelectObject(DC, pwc->clearPen); 
+	HBRUSH Old_Brush = SelectObject(DC, pwc->clearBrush);
+	Rectangle(DC,
+		  x,
+		  FLIP(y) + 1,
+		  x + width + 1,
+		  FLIP(y) - height + 1);
+	SelectObject(DC, Old_Pen); 
+	SelectObject(DC, Old_Brush); 
+	mask &= ~BUFFER_BIT_FRONT_LEFT;
+    } /* front buffer */ 
+    
+    /* Call swrast if there is anything left to clear (like DEPTH) */ 
+    if (mask) 
+	_swrast_Clear(ctx, mask);
+  
+#undef FLIP
+} 
+
+
+/**********************************************************************/
+/*****                   PIXEL Functions                          *****/
+/**********************************************************************/
+
+#define FLIP(Y)  (rb->Height - (Y) - 1)
+
+
+/**
+ ** Front Buffer reading/writing
+ ** These are slow, but work with all non-indexed visual types.
+ **/
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span_front(struct gl_context *ctx, 
+				  struct gl_renderbuffer *rb, 
+				  GLuint n, GLint x, GLint y,
+				  const void *values, 
+				  const GLubyte *mask)
+{
+   const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+   WMesaContext pwc = wmesa_context(ctx);
+   WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(pwc->hDC);
+   HBITMAP bmp=0;
+   HDC mdc=0;
+   typedef union
+   {
+      unsigned i;
+      struct {
+         unsigned b:8, g:8, r:8, a:8;
+      };
+   } BGRA;
+   BGRA *bgra, c;
+   GLuint i;
+
+   if (n < 16) {   // the value 16 is just guessed
+      y=FLIP(y);
+      if (mask) {
+         for (i=0; i<n; i++)
+            if (mask[i])
+               SetPixel(pwc->hDC, x+i, y,
+                        RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+      }
+      else {
+         for (i=0; i<n; i++)
+            SetPixel(pwc->hDC, x+i, y,
+                     RGB(rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]));
+      }
+   }
+   else {
+      if (!pwfb) {
+         _mesa_problem(NULL, "wmesa: write_rgba_span_front on unknown hdc");
+         return;
+      }
+      bgra=malloc(n*sizeof(BGRA));
+      if (!bgra) {
+         _mesa_problem(NULL, "wmesa: write_rgba_span_front: out of memory");
+         return;
+      }
+      c.a=0;
+      if (mask) {
+         for (i=0; i<n; i++) {
+            if (mask[i]) {
+               c.r=rgba[i][RCOMP];
+               c.g=rgba[i][GCOMP];
+               c.b=rgba[i][BCOMP];
+               c.a=rgba[i][ACOMP];
+               bgra[i]=c;
+            }
+            else
+               bgra[i].i=0;
+         }
+      }
+      else {
+         for (i=0; i<n; i++) {
+            c.r=rgba[i][RCOMP];
+            c.g=rgba[i][GCOMP];
+            c.b=rgba[i][BCOMP];
+            c.a=rgba[i][ACOMP];
+            bgra[i]=c;
+         }
+      }
+      bmp=CreateBitmap(n, 1,  1, 32, bgra);
+      mdc=CreateCompatibleDC(pwfb->hDC);
+      SelectObject(mdc, bmp);
+      y=FLIP(y);
+      BitBlt(pwfb->hDC, x, y, n, 1, mdc, 0, 0, SRCCOPY);
+      SelectObject(mdc, 0);
+      DeleteObject(bmp);
+      DeleteDC(mdc);
+      free(bgra);
+   }
+}
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span_front(struct gl_context *ctx, 
+				 struct gl_renderbuffer *rb, 
+				 GLuint n, GLint x, GLint y,
+				 const void *values, 
+				 const GLubyte *mask)
+{
+    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;
+    WMesaContext pwc = wmesa_context(ctx);
+    GLuint i;
+    
+    (void) ctx;
+    y=FLIP(y);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+		SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 
+					       rgb[i][BCOMP]));
+    }
+    else {
+	for (i=0; i<n; i++)
+	    SetPixel(pwc->hDC, x+i, y, RGB(rgb[i][RCOMP], rgb[i][GCOMP], 
+					   rgb[i][BCOMP]));
+    }
+    
+}
+
+/*
+ * Write a horizontal span of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_span_front(struct gl_context *ctx, 
+                                       struct gl_renderbuffer *rb,
+                                       GLuint n, GLint x, GLint y,
+                                       const void *value, 
+                                       const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    GLuint i;
+    WMesaContext pwc = wmesa_context(ctx);
+    COLORREF colorref;
+
+    (void) ctx;
+    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
+    y=FLIP(y);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+		SetPixel(pwc->hDC, x+i, y, colorref);
+    }
+    else
+	for (i=0; i<n; i++)
+	    SetPixel(pwc->hDC, x+i, y, colorref);
+
+}
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels_front(struct gl_context *ctx, 
+                                    struct gl_renderbuffer *rb,
+                                    GLuint n, 
+                                    const GLint x[], const GLint y[],
+                                    const void *values, 
+                                    const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    GLuint i;
+    WMesaContext pwc = wmesa_context(ctx);
+    (void) ctx;
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), 
+		     RGB(rgba[i][RCOMP], rgba[i][GCOMP], 
+			 rgba[i][BCOMP]));
+}
+
+
+
+/*
+ * Write an array of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_pixels_front(struct gl_context *ctx, 
+                                         struct gl_renderbuffer *rb,
+                                         GLuint n,
+                                         const GLint x[], const GLint y[],
+                                         const void *value,
+                                         const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    GLuint i;
+    WMesaContext pwc = wmesa_context(ctx);
+    COLORREF colorref;
+    (void) ctx;
+    colorref = RGB(color[RCOMP], color[GCOMP], color[BCOMP]);
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    SetPixel(pwc->hDC, x[i], FLIP(y[i]), colorref);
+}
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span_front(struct gl_context *ctx, 
+                                 struct gl_renderbuffer *rb,
+                                 GLuint n, GLint x, GLint y,
+                                 void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    WMesaContext pwc = wmesa_context(ctx);
+    GLuint i;
+    COLORREF Color;
+    y = FLIP(y);
+    for (i=0; i<n; i++) {
+	Color = GetPixel(pwc->hDC, x+i, y);
+	rgba[i][RCOMP] = GetRValue(Color);
+	rgba[i][GCOMP] = GetGValue(Color);
+	rgba[i][BCOMP] = GetBValue(Color);
+	rgba[i][ACOMP] = 255;
+    }
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels_front(struct gl_context *ctx, 
+                                   struct gl_renderbuffer *rb,
+                                   GLuint n, const GLint x[], const GLint y[],
+                                   void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    WMesaContext pwc = wmesa_context(ctx);
+    GLuint i;
+    COLORREF Color;
+    for (i=0; i<n; i++) {
+        GLint y2 = FLIP(y[i]);
+        Color = GetPixel(pwc->hDC, x[i], y2);
+        rgba[i][RCOMP] = GetRValue(Color);
+        rgba[i][GCOMP] = GetGValue(Color);
+        rgba[i][BCOMP] = GetBValue(Color);
+        rgba[i][ACOMP] = 255;
+    }
+}
+
+/*********************************************************************/
+
+/* DOUBLE BUFFER 32-bit */
+
+#define WMSETPIXEL32(pwc, y, x, r, g, b) { \
+LPDWORD lpdw = ((LPDWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \
+*lpdw = BGR32((r),(g),(b)); }
+
+
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span_32(struct gl_context *ctx, 
+			       struct gl_renderbuffer *rb, 
+			       GLuint n, GLint x, GLint y,
+			       const void *values, 
+			       const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPDWORD lpdw;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpdw[i] = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 
+				rgba[i][BCOMP]);
+    }
+    else {
+	for (i=0; i<n; i++)
+                *lpdw++ = BGR32(rgba[i][RCOMP], rgba[i][GCOMP], 
+				rgba[i][BCOMP]);
+    }
+}
+
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span_32(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb, 
+			      GLuint n, GLint x, GLint y,
+			      const void *values, 
+			      const GLubyte *mask)
+{
+    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPDWORD lpdw;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpdw[i] = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 
+				rgb[i][BCOMP]);
+    }
+    else {
+	for (i=0; i<n; i++)
+                *lpdw++ = BGR32(rgb[i][RCOMP], rgb[i][GCOMP], 
+				rgb[i][BCOMP]);
+    }
+}
+
+/*
+ * Write a horizontal span of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_span_32(struct gl_context *ctx, 
+				    struct gl_renderbuffer *rb,
+				    GLuint n, GLint x, GLint y,
+				    const void *value, 
+				    const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    LPDWORD lpdw;
+    DWORD pixel;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    y=FLIP(y);
+    pixel = BGR32(color[RCOMP], color[GCOMP], color[BCOMP]);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpdw[i] = pixel;
+    }
+    else
+	for (i=0; i<n; i++)
+                *lpdw++ = pixel;
+
+}
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels_32(struct gl_context *ctx, 
+				 struct gl_renderbuffer *rb,
+				 GLuint n, const GLint x[], const GLint y[],
+				 const void *values, 
+				 const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL32(pwfb, FLIP(y[i]), x[i],
+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+}
+
+/*
+ * Write an array of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_pixels_32(struct gl_context *ctx, 
+				      struct gl_renderbuffer *rb,
+				      GLuint n,
+				      const GLint x[], const GLint y[],
+				      const void *value,
+				      const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL32(pwfb, FLIP(y[i]),x[i],color[RCOMP],
+			 color[GCOMP], color[BCOMP]);
+}
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span_32(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb,
+			      GLuint n, GLint x, GLint y,
+			      void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i;
+    DWORD pixel;
+    LPDWORD lpdw;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    
+    y = FLIP(y);
+    lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    for (i=0; i<n; i++) {
+	pixel = lpdw[i];
+	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);
+	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);
+	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);
+	rgba[i][ACOMP] = 255;
+    }
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels_32(struct gl_context *ctx, 
+				struct gl_renderbuffer *rb,
+				GLuint n, const GLint x[], const GLint y[],
+				void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i;
+    DWORD pixel;
+    LPDWORD lpdw;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+
+    for (i=0; i<n; i++) {
+	GLint y2 = FLIP(y[i]);
+	lpdw = ((LPDWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];
+	pixel = *lpdw;
+	rgba[i][RCOMP] = (GLubyte)((pixel & 0x00ff0000) >> 16);
+	rgba[i][GCOMP] = (GLubyte)((pixel & 0x0000ff00) >> 8);
+	rgba[i][BCOMP] = (GLubyte)(pixel & 0x000000ff);
+	rgba[i][ACOMP] = 255;
+  }
+}
+
+
+/*********************************************************************/
+
+/* DOUBLE BUFFER 24-bit */
+
+#define WMSETPIXEL24(pwc, y, x, r, g, b) { \
+LPBYTE lpb = ((LPBYTE)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (3 * x)); \
+lpb[0] = (b); \
+lpb[1] = (g); \
+lpb[2] = (r); }
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span_24(struct gl_context *ctx, 
+			       struct gl_renderbuffer *rb, 
+			       GLuint n, GLint x, GLint y,
+			       const void *values, 
+			       const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPBYTE lpb;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i]) {
+                lpb[3*i] = rgba[i][BCOMP];
+                lpb[3*i+1] = rgba[i][GCOMP];
+                lpb[3*i+2] = rgba[i][RCOMP];
+	    }
+    }
+    else {
+	    for (i=0; i<n; i++) {
+            *lpb++ = rgba[i][BCOMP];
+            *lpb++ = rgba[i][GCOMP];
+            *lpb++ = rgba[i][RCOMP];
+	    }
+    }
+}
+
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span_24(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb, 
+			      GLuint n, GLint x, GLint y,
+			      const void *values, 
+			      const GLubyte *mask)
+{
+    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPBYTE lpb;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i]) {
+            lpb[3*i] = rgb[i][BCOMP];
+            lpb[3*i+1] = rgb[i][GCOMP];
+            lpb[3*i+2] = rgb[i][RCOMP];
+	    }
+    }
+    else {
+    	for (i=0; i<n; i++) {
+    		*lpb++ = rgb[i][BCOMP];
+    		*lpb++ = rgb[i][GCOMP];
+    		*lpb++ = rgb[i][RCOMP];
+    	}
+    }
+}
+
+/*
+ * Write a horizontal span of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_span_24(struct gl_context *ctx, 
+				    struct gl_renderbuffer *rb,
+				    GLuint n, GLint x, GLint y,
+				    const void *value, 
+				    const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    LPBYTE lpb;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
+    y=FLIP(y);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i]) {
+	    	lpb[3*i] = color[BCOMP];
+	    	lpb[3*i+1] = color[GCOMP];
+	    	lpb[3*i+2] = color[RCOMP];
+	    }
+    }
+    else
+	for (i=0; i<n; i++) {
+		*lpb++ = color[BCOMP];
+		*lpb++ = color[GCOMP];
+		*lpb++ = color[RCOMP];		
+	}
+}
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels_24(struct gl_context *ctx, 
+				 struct gl_renderbuffer *rb,
+				 GLuint n, const GLint x[], const GLint y[],
+				 const void *values, 
+				 const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL24(pwfb, FLIP(y[i]), x[i],
+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+}
+
+/*
+ * Write an array of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_pixels_24(struct gl_context *ctx, 
+				      struct gl_renderbuffer *rb,
+				      GLuint n,
+				      const GLint x[], const GLint y[],
+				      const void *value,
+				      const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL24(pwfb, FLIP(y[i]),x[i],color[RCOMP],
+			 color[GCOMP], color[BCOMP]);
+}
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span_24(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb,
+			      GLuint n, GLint x, GLint y,
+			      void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i;
+    LPBYTE lpb;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    
+    y = FLIP(y);
+    lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y)) + (3 * x);
+    for (i=0; i<n; i++) {
+	rgba[i][RCOMP] = lpb[3*i+2];
+	rgba[i][GCOMP] = lpb[3*i+1];
+	rgba[i][BCOMP] = lpb[3*i];
+	rgba[i][ACOMP] = 255;
+    }
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels_24(struct gl_context *ctx, 
+				struct gl_renderbuffer *rb,
+				GLuint n, const GLint x[], const GLint y[],
+				void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i;
+    LPBYTE lpb;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+
+    for (i=0; i<n; i++) {
+	GLint y2 = FLIP(y[i]);
+	lpb = ((LPBYTE)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + (3 * x[i]);
+	rgba[i][RCOMP] = lpb[3*i+2];
+	rgba[i][GCOMP] = lpb[3*i+1];
+	rgba[i][BCOMP] = lpb[3*i];
+	rgba[i][ACOMP] = 255;
+  }
+}
+
+
+/*********************************************************************/
+
+/* DOUBLE BUFFER 16-bit */
+
+#define WMSETPIXEL16(pwc, y, x, r, g, b) { \
+LPWORD lpw = ((LPWORD)((pwc)->pbPixels + (pwc)->ScanWidth * (y)) + (x)); \
+*lpw = BGR16((r),(g),(b)); }
+
+
+
+/* Write a horizontal span of RGBA color pixels with a boolean mask. */
+static void write_rgba_span_16(struct gl_context *ctx, 
+			       struct gl_renderbuffer *rb, 
+			       GLuint n, GLint x, GLint y,
+			       const void *values, 
+			       const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPWORD lpw;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpw[i] = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 
+			       rgba[i][BCOMP]);
+    }
+    else {
+	for (i=0; i<n; i++)
+                *lpw++ = BGR16(rgba[i][RCOMP], rgba[i][GCOMP], 
+			       rgba[i][BCOMP]);
+    }
+}
+
+
+/* Write a horizontal span of RGB color pixels with a boolean mask. */
+static void write_rgb_span_16(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb, 
+			      GLuint n, GLint x, GLint y,
+			      const void *values, 
+			      const GLubyte *mask)
+{
+    const GLubyte (*rgb)[3] = (const GLubyte (*)[3])values;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    GLuint i;
+    LPWORD lpw;
+
+    (void) ctx;
+    
+    y=FLIP(y);
+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpw[i] = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 
+			       rgb[i][BCOMP]);
+    }
+    else {
+	for (i=0; i<n; i++)
+                *lpw++ = BGR16(rgb[i][RCOMP], rgb[i][GCOMP], 
+			       rgb[i][BCOMP]);
+    }
+}
+
+/*
+ * Write a horizontal span of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_span_16(struct gl_context *ctx, 
+				    struct gl_renderbuffer *rb,
+				    GLuint n, GLint x, GLint y,
+				    const void *value, 
+				    const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    LPWORD lpw;
+    WORD pixel;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    (void) ctx;
+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    y=FLIP(y);
+    pixel = BGR16(color[RCOMP], color[GCOMP], color[BCOMP]);
+    if (mask) {
+	for (i=0; i<n; i++)
+	    if (mask[i])
+                lpw[i] = pixel;
+    }
+    else
+	for (i=0; i<n; i++)
+                *lpw++ = pixel;
+
+}
+
+/* Write an array of RGBA pixels with a boolean mask. */
+static void write_rgba_pixels_16(struct gl_context *ctx, 
+				 struct gl_renderbuffer *rb,
+				 GLuint n, const GLint x[], const GLint y[],
+				 const void *values, 
+				 const GLubyte *mask)
+{
+    const GLubyte (*rgba)[4] = (const GLubyte (*)[4])values;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    (void) ctx;
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL16(pwfb, FLIP(y[i]), x[i],
+			 rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
+}
+
+/*
+ * Write an array of pixels with a boolean mask.  The current color
+ * is used for all pixels.
+ */
+static void write_mono_rgba_pixels_16(struct gl_context *ctx, 
+				      struct gl_renderbuffer *rb,
+				      GLuint n,
+				      const GLint x[], const GLint y[],
+				      const void *value,
+				      const GLubyte *mask)
+{
+    const GLchan *color = (const GLchan *)value;
+    GLuint i;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    (void) ctx;
+    for (i=0; i<n; i++)
+	if (mask[i])
+	    WMSETPIXEL16(pwfb, FLIP(y[i]),x[i],color[RCOMP],
+			 color[GCOMP], color[BCOMP]);
+}
+
+/* Read a horizontal span of color pixels. */
+static void read_rgba_span_16(struct gl_context *ctx, 
+			      struct gl_renderbuffer *rb,
+			      GLuint n, GLint x, GLint y,
+			      void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i, pixel;
+    LPWORD lpw;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+    
+    y = FLIP(y);
+    lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y)) + x;
+    for (i=0; i<n; i++) {
+	pixel = lpw[i];
+	/* Windows uses 5,5,5 for 16-bit */
+	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;
+	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;
+	rgba[i][BCOMP] = (pixel & 0x001f) << 3;
+	rgba[i][ACOMP] = 255;
+    }
+}
+
+
+/* Read an array of color pixels. */
+static void read_rgba_pixels_16(struct gl_context *ctx, 
+				struct gl_renderbuffer *rb,
+				GLuint n, const GLint x[], const GLint y[],
+				void *values)
+{
+    GLubyte (*rgba)[4] = (GLubyte (*)[4])values;
+    GLuint i, pixel;
+    LPWORD lpw;
+    WMesaFramebuffer pwfb = wmesa_framebuffer(ctx->DrawBuffer);
+
+    for (i=0; i<n; i++) {
+	GLint y2 = FLIP(y[i]);
+	lpw = ((LPWORD)(pwfb->pbPixels + pwfb->ScanWidth * y2)) + x[i];
+	pixel = *lpw;
+	/* Windows uses 5,5,5 for 16-bit */
+	rgba[i][RCOMP] = (pixel & 0x7c00) >> 7;
+	rgba[i][GCOMP] = (pixel & 0x03e0) >> 2;
+	rgba[i][BCOMP] = (pixel & 0x001f) << 3;
+	rgba[i][ACOMP] = 255;
+  }
+}
+
+
+
+
+/**********************************************************************/
+/*****                   BUFFER Functions                         *****/
+/**********************************************************************/
+
+
+
+
+static void
+wmesa_delete_renderbuffer(struct gl_renderbuffer *rb)
+{
+    free(rb);
+}
+
+
+/**
+ * This is called by Mesa whenever it determines that the window size
+ * has changed.  Do whatever's needed to cope with that.
+ */
+static GLboolean
+wmesa_renderbuffer_storage(struct gl_context *ctx, 
+			   struct gl_renderbuffer *rb,
+			   GLenum internalFormat, 
+			   GLuint width, 
+			   GLuint height)
+{
+    rb->Width = width;
+    rb->Height = height;
+    return GL_TRUE;
+}
+
+
+/**
+ * Plug in the Get/PutRow/Values functions for a renderbuffer depending
+ * on if we're drawing to the front or back color buffer.
+ */
+static void
+wmesa_set_renderbuffer_funcs(struct gl_renderbuffer *rb, int pixelformat,
+                             int cColorBits, int double_buffer)
+{
+    if (double_buffer) {
+        /* back buffer */
+	/* Picking the correct span functions is important because
+	 * the DIB was allocated with the indicated depth. */
+	switch(pixelformat) {
+	case PF_5R6G5B:
+	    rb->PutRow = write_rgba_span_16;
+	    rb->PutRowRGB = write_rgb_span_16;
+	    rb->PutMonoRow = write_mono_rgba_span_16;
+	    rb->PutValues = write_rgba_pixels_16;
+	    rb->PutMonoValues = write_mono_rgba_pixels_16;
+	    rb->GetRow = read_rgba_span_16;
+	    rb->GetValues = read_rgba_pixels_16;
+	    break;
+	case PF_8R8G8B:
+		if (cColorBits == 24)
+		{
+		    rb->PutRow = write_rgba_span_24;
+		    rb->PutRowRGB = write_rgb_span_24;
+		    rb->PutMonoRow = write_mono_rgba_span_24;
+		    rb->PutValues = write_rgba_pixels_24;
+		    rb->PutMonoValues = write_mono_rgba_pixels_24;
+		    rb->GetRow = read_rgba_span_24;
+		    rb->GetValues = read_rgba_pixels_24;
+		}
+		else
+		{
+	        rb->PutRow = write_rgba_span_32;
+	        rb->PutRowRGB = write_rgb_span_32;
+	        rb->PutMonoRow = write_mono_rgba_span_32;
+	        rb->PutValues = write_rgba_pixels_32;
+	        rb->PutMonoValues = write_mono_rgba_pixels_32;
+	        rb->GetRow = read_rgba_span_32;
+	        rb->GetValues = read_rgba_pixels_32;
+		}
+	    break;
+	default:
+	    break;
+	}
+    }
+    else {
+        /* front buffer (actual Windows window) */
+	rb->PutRow = write_rgba_span_front;
+	rb->PutRowRGB = write_rgb_span_front;
+	rb->PutMonoRow = write_mono_rgba_span_front;
+	rb->PutValues = write_rgba_pixels_front;
+	rb->PutMonoValues = write_mono_rgba_pixels_front;
+	rb->GetRow = read_rgba_span_front;
+	rb->GetValues = read_rgba_pixels_front;
+    }
+}
+
+/**
+ * Called by ctx->Driver.ResizeBuffers()
+ * Resize the front/back colorbuffers to match the latest window size.
+ */
+static void
+wmesa_resize_buffers(struct gl_context *ctx, struct gl_framebuffer *buffer,
+                     GLuint width, GLuint height)
+{
+    WMesaFramebuffer pwfb = wmesa_framebuffer(buffer);
+
+    if (pwfb->Base.Width != width || pwfb->Base.Height != height) {
+	/* Realloc back buffer */
+	if (ctx->Visual.doubleBufferMode == 1) {
+	    wmDeleteBackingStore(pwfb);
+	    wmCreateBackingStore(pwfb, width, height);
+	}
+    }
+    _mesa_resize_framebuffer(ctx, buffer, width, height);
+}
+
+
+/**
+ * Called by glViewport.
+ * This is a good time for us to poll the current window size and adjust
+ * our renderbuffers to match the current window size.
+ * Remember, we have no opportunity to respond to conventional
+ * resize events since the driver has no event loop.
+ * Thus, we poll.
+ * MakeCurrent also ends up making a call here, so that ensures
+ * we get the viewport set correctly, even if the app does not call
+ * glViewport and relies on the defaults.
+ */
+static void wmesa_viewport(struct gl_context *ctx, 
+			   GLint x, GLint y, 
+			   GLsizei width, GLsizei height)
+{
+    GLuint new_width, new_height;
+
+    wmesa_get_buffer_size(ctx->WinSysDrawBuffer, &new_width, &new_height);
+
+    /**
+     * Resize buffers if the window size changed.
+     */
+    wmesa_resize_buffers(ctx, ctx->WinSysDrawBuffer, new_width, new_height);
+    ctx->NewState |= _NEW_BUFFERS;  /* to update scissor / window bounds */
+}
+
+
+
+
+/**
+ * Called when the driver should update it's state, based on the new_state
+ * flags.
+ */
+static void wmesa_update_state(struct gl_context *ctx, GLuint new_state)
+{
+    _swrast_InvalidateState(ctx, new_state);
+    _swsetup_InvalidateState(ctx, new_state);
+    _vbo_InvalidateState(ctx, new_state);
+    _tnl_InvalidateState(ctx, new_state);
+
+    /* TODO - This code is not complete yet because I 
+     * don't know what to do for all state updates.
+     */
+
+    if (new_state & _NEW_BUFFERS) {
+    }
+}
+
+
+
+
+
+/**********************************************************************/
+/*****                   WMESA Functions                          *****/
+/**********************************************************************/
+
+WMesaContext WMesaCreateContext(HDC hDC, 
+				HPALETTE* Pal,
+				GLboolean rgb_flag,
+				GLboolean db_flag,
+				GLboolean alpha_flag)
+{
+    WMesaContext c;
+    struct dd_function_table functions;
+    GLint red_bits, green_bits, blue_bits, alpha_bits;
+    struct gl_context *ctx;
+    struct gl_config *visual;
+
+    (void) Pal;
+    
+    /* Indexed mode not supported */
+    if (!rgb_flag)
+	return NULL;
+
+    /* Allocate wmesa context */
+    c = CALLOC_STRUCT(wmesa_context);
+    if (!c)
+	return NULL;
+
+#if 0
+    /* I do not understand this contributed code */
+    /* Support memory and device contexts */
+    if(WindowFromDC(hDC) != NULL) {
+	c->hDC = GetDC(WindowFromDC(hDC)); /* huh ???? */
+    }
+    else {
+	c->hDC = hDC;
+    }
+#else
+    c->hDC = hDC;
+#endif
+
+    /* Get data for visual */
+    /* Dealing with this is actually a bit of overkill because Mesa will end
+     * up treating all color component size requests less than 8 by using 
+     * a single byte per channel.  In addition, the interface to the span
+     * routines passes colors as an entire byte per channel anyway, so there
+     * is nothing to be saved by telling the visual to be 16 bits if the device
+     * is 16 bits.  That is, Mesa is going to compute colors down to 8 bits per
+     * channel anyway.
+     * But we go through the motions here anyway.
+     */
+    switch (GetDeviceCaps(c->hDC, BITSPIXEL)) {
+    case 16:
+	red_bits = green_bits = blue_bits = 5;
+	alpha_bits = 0;
+	break;
+    default:
+	red_bits = green_bits = blue_bits = 8;
+	alpha_bits = 8;
+	break;
+    }
+    /* Create visual based on flags */
+    visual = _mesa_create_visual(db_flag,    /* db_flag */
+                                 GL_FALSE,   /* stereo */
+                                 red_bits, green_bits, blue_bits, /* color RGB */
+                                 alpha_flag ? alpha_bits : 0, /* color A */
+                                 DEFAULT_SOFTWARE_DEPTH_BITS, /* depth_bits */
+                                 8,          /* stencil_bits */
+                                 16,16,16,   /* accum RGB */
+                                 alpha_flag ? 16 : 0, /* accum A */
+                                 1);         /* num samples */
+    
+    if (!visual) {
+	free(c);
+	return NULL;
+    }
+
+    /* Set up driver functions */
+    _mesa_init_driver_functions(&functions);
+    functions.GetString = wmesa_get_string;
+    functions.UpdateState = wmesa_update_state;
+    functions.GetBufferSize = wmesa_get_buffer_size;
+    functions.Flush = wmesa_flush;
+    functions.Clear = clear;
+    functions.ClearColor = clear_color;
+    functions.ResizeBuffers = wmesa_resize_buffers;
+    functions.Viewport = wmesa_viewport;
+
+    /* initialize the Mesa context data */
+    ctx = &c->gl_ctx;
+    _mesa_initialize_context(ctx, API_OPENGL, visual,
+                             NULL, &functions, (void *)c);
+
+    /* visual no longer needed - it was copied by _mesa_initialize_context() */
+    _mesa_destroy_visual(visual);
+
+    _mesa_enable_sw_extensions(ctx);
+    _mesa_enable_1_3_extensions(ctx);
+    _mesa_enable_1_4_extensions(ctx);
+    _mesa_enable_1_5_extensions(ctx);
+    _mesa_enable_2_0_extensions(ctx);
+    _mesa_enable_2_1_extensions(ctx);
+  
+    _mesa_meta_init(ctx);
+
+    /* Initialize the software rasterizer and helper modules. */
+    if (!_swrast_CreateContext(ctx) ||
+        !_vbo_CreateContext(ctx) ||
+        !_tnl_CreateContext(ctx) ||
+	!_swsetup_CreateContext(ctx)) {
+	_mesa_free_context_data(ctx);
+	free(c);
+	return NULL;
+    }
+    _swsetup_Wakeup(ctx);
+    TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
+
+    return c;
+}
+
+
+void WMesaDestroyContext( WMesaContext pwc )
+{
+    struct gl_context *ctx = &pwc->gl_ctx;
+    WMesaFramebuffer pwfb;
+    GET_CURRENT_CONTEXT(cur_ctx);
+
+    if (cur_ctx == ctx) {
+        /* unbind current if deleting current context */
+        WMesaMakeCurrent(NULL, NULL);
+    }
+
+    /* clean up frame buffer resources */
+    pwfb = wmesa_lookup_framebuffer(pwc->hDC);
+    if (pwfb) {
+	if (ctx->Visual.doubleBufferMode == 1)
+	    wmDeleteBackingStore(pwfb);
+	wmesa_free_framebuffer(pwc->hDC);
+    }
+
+    /* Release for device, not memory contexts */
+    if (WindowFromDC(pwc->hDC) != NULL)
+    {
+      ReleaseDC(WindowFromDC(pwc->hDC), pwc->hDC);
+    }
+    DeleteObject(pwc->clearPen); 
+    DeleteObject(pwc->clearBrush); 
+    
+    _mesa_meta_free(ctx);
+
+    _swsetup_DestroyContext(ctx);
+    _tnl_DestroyContext(ctx);
+    _vbo_DestroyContext(ctx);
+    _swrast_DestroyContext(ctx);
+    
+    _mesa_free_context_data(ctx);
+    free(pwc);
+}
+
+
+/**
+ * Create a new color renderbuffer.
+ */
+static struct gl_renderbuffer *
+wmesa_new_renderbuffer(void)
+{
+    struct gl_renderbuffer *rb = CALLOC_STRUCT(gl_renderbuffer);
+    if (!rb)
+        return NULL;
+
+    _mesa_init_renderbuffer(rb, (GLuint)0);
+    
+    rb->_BaseFormat = GL_RGBA;
+    rb->InternalFormat = GL_RGBA;
+    rb->DataType = CHAN_TYPE;
+    rb->Delete = wmesa_delete_renderbuffer;
+    rb->AllocStorage = wmesa_renderbuffer_storage;
+    return rb;
+}
+
+
+void WMesaMakeCurrent(WMesaContext c, HDC hdc)
+{
+    WMesaFramebuffer pwfb;
+
+    {
+        /* return if already current */
+        GET_CURRENT_CONTEXT(ctx);
+        WMesaContext pwc = wmesa_context(ctx);
+        if (pwc && c == pwc && pwc->hDC == hdc)
+            return;
+    }
+
+    pwfb = wmesa_lookup_framebuffer(hdc);
+
+    /* Lazy creation of framebuffers */
+    if (c && !pwfb && hdc) {
+        struct gl_renderbuffer *rb;
+        struct gl_config *visual = &c->gl_ctx.Visual;
+        GLuint width, height;
+
+        get_window_size(hdc, &width, &height);
+
+	c->clearPen = CreatePen(PS_SOLID, 1, 0); 
+	c->clearBrush = CreateSolidBrush(0); 
+
+        pwfb = wmesa_new_framebuffer(hdc, visual);
+
+	/* Create back buffer if double buffered */
+	if (visual->doubleBufferMode == 1) {
+	    wmCreateBackingStore(pwfb, width, height);
+	}
+	
+        /* make render buffers */
+        if (visual->doubleBufferMode == 1) {
+            rb = wmesa_new_renderbuffer();
+            _mesa_add_renderbuffer(&pwfb->Base, BUFFER_BACK_LEFT, rb);
+            wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 1);
+	}
+        rb = wmesa_new_renderbuffer();
+        _mesa_add_renderbuffer(&pwfb->Base, BUFFER_FRONT_LEFT, rb);
+        wmesa_set_renderbuffer_funcs(rb, pwfb->pixelformat, pwfb->cColorBits, 0);
+
+	/* Let Mesa own the Depth, Stencil, and Accum buffers */
+        _mesa_add_soft_renderbuffers(&pwfb->Base,
+                                     GL_FALSE, /* color */
+                                     visual->depthBits > 0,
+                                     visual->stencilBits > 0,
+                                     visual->accumRedBits > 0,
+                                     visual->alphaBits >0, 
+                                     GL_FALSE);
+    }
+
+    if (c && pwfb)
+	_mesa_make_current(&c->gl_ctx, &pwfb->Base, &pwfb->Base);
+    else
+        _mesa_make_current(NULL, NULL, NULL);
+}
+
+
+void WMesaSwapBuffers( HDC hdc )
+{
+    GET_CURRENT_CONTEXT(ctx);
+    WMesaContext pwc = wmesa_context(ctx);
+    WMesaFramebuffer pwfb = wmesa_lookup_framebuffer(hdc);
+
+    if (!pwfb) {
+        _mesa_problem(NULL, "wmesa: swapbuffers on unknown hdc");
+        return;
+    }
+
+    /* If we're swapping the buffer associated with the current context
+     * we have to flush any pending rendering commands first.
+     */
+    if (pwc->hDC == hdc) {
+	_mesa_notifySwapBuffers(ctx);
+
+	BitBlt(pwfb->hDC, 0, 0, pwfb->Base.Width, pwfb->Base.Height,
+	       pwfb->dib_hDC, 0, 0, SRCCOPY);
+    }
+    else {
+        /* XXX for now only allow swapping current window */
+        _mesa_problem(NULL, "wmesa: can't swap non-current window");
+    }
+}
+
+void WMesaShareLists(WMesaContext ctx_to_share, WMesaContext ctx)
+{
+	_mesa_share_state(&ctx->gl_ctx, &ctx_to_share->gl_ctx);	
+}
+
diff --git a/mesalib/src/mesa/drivers/windows/gdi/wmesadef.h b/mesalib/src/mesa/drivers/windows/gdi/wmesadef.h
index 344f9488b..9fda88390 100644
--- a/mesalib/src/mesa/drivers/windows/gdi/wmesadef.h
+++ b/mesalib/src/mesa/drivers/windows/gdi/wmesadef.h
@@ -1,43 +1,43 @@
-#ifndef WMESADEF_H

-#define WMESADEF_H

-

-#include <windows.h>

-

-#include "main/context.h"

-

-

-/**

- * The Windows Mesa rendering context, derived from struct gl_context.

- */

-struct wmesa_context {

-    struct gl_context           gl_ctx;	        /* The core GL/Mesa context */

-    HDC                 hDC;

-    COLORREF		clearColorRef;

-    HPEN                clearPen;

-    HBRUSH              clearBrush;

-};

-

-

-/**

- * Windows framebuffer, derived from gl_framebuffer

- */

-struct wmesa_framebuffer

-{

-    struct gl_framebuffer Base;

-    HDC                 hDC;

-    int			pixelformat;

-    GLuint		ScanWidth;

-    int			cColorBits;

-    /* back buffer DIB fields */

-    HDC                 dib_hDC;

-    BITMAPINFO          bmi;

-    HBITMAP             hbmDIB;

-    HBITMAP             hOldBitmap;

-    PBYTE               pbPixels;

-    struct wmesa_framebuffer *next;

-};

-

-typedef struct wmesa_framebuffer *WMesaFramebuffer;

-

-

-#endif /* WMESADEF_H */

+#ifndef WMESADEF_H
+#define WMESADEF_H
+
+#include <windows.h>
+
+#include "main/context.h"
+
+
+/**
+ * The Windows Mesa rendering context, derived from struct gl_context.
+ */
+struct wmesa_context {
+    struct gl_context           gl_ctx;	        /* The core GL/Mesa context */
+    HDC                 hDC;
+    COLORREF		clearColorRef;
+    HPEN                clearPen;
+    HBRUSH              clearBrush;
+};
+
+
+/**
+ * Windows framebuffer, derived from gl_framebuffer
+ */
+struct wmesa_framebuffer
+{
+    struct gl_framebuffer Base;
+    HDC                 hDC;
+    int			pixelformat;
+    GLuint		ScanWidth;
+    int			cColorBits;
+    /* back buffer DIB fields */
+    HDC                 dib_hDC;
+    BITMAPINFO          bmi;
+    HBITMAP             hbmDIB;
+    HBITMAP             hOldBitmap;
+    PBYTE               pbPixels;
+    struct wmesa_framebuffer *next;
+};
+
+typedef struct wmesa_framebuffer *WMesaFramebuffer;
+
+
+#endif /* WMESADEF_H */