git.oblomov.eu Git - wine/blob - dlls/wined3d/surface.c

   1 /*
   2  * IWineD3DSurface Implementation
   3  *
   4  * Copyright 1998 Lionel Ulmer
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  * Copyright 2002-2005 Jason Edmeades
   7  * Copyright 2002-2003 Raphael Junqueira
   8  * Copyright 2004 Christian Costa
   9  * Copyright 2005 Oliver Stieber
  10  * Copyright 2006 Stefan Dösinger for CodeWeavers
  11  * Copyright 2007 Henri Verbeet
  12  * Copyright 2006-2007 Roderick Colenbrander
  13  *
  14  * This library is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU Lesser General Public
  16  * License as published by the Free Software Foundation; either
  17  * version 2.1 of the License, or (at your option) any later version.
  18  *
  19  * This library is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22  * Lesser General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU Lesser General Public
  25  * License along with this library; if not, write to the Free Software
  26  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31 #include "wined3d_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
  34 #define GLINFO_LOCATION This->resource.wineD3DDevice->adapter->gl_info
  35
  36 HRESULT d3dfmt_convert_surface(BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *surf);
  37
  38 static void surface_download_data(IWineD3DSurfaceImpl *This) {
  39     if (!(This->resource.allocatedMemory || This->Flags & SFLAG_PBO)) This->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), 0, This->resource.size + 4);
  40     if (This->resource.format == WINED3DFMT_DXT1 ||
  41             This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 ||
  42             This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) {
  43         if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) { /* We can assume this as the texture would not have been created otherwise */
  44             FIXME("(%p) : Attempting to lock a compressed texture when texture compression isn't supported by opengl\n", This);
  45         } else {
  46             TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p\n", This, This->glDescription.level,
  47                 This->glDescription.glFormat, This->glDescription.glType, This->resource.allocatedMemory);
  48
  49             GL_EXTCALL(glGetCompressedTexImageARB(This->glDescription.target, This->glDescription.level, This->resource.allocatedMemory));
  50             checkGLcall("glGetCompressedTexImageARB()");
  51         }
  52     } else {
  53         void *mem;
  54         int src_pitch = 0;
  55         int dst_pitch = 0;
  56
  57          if(This->Flags & SFLAG_CONVERTED) {
  58              FIXME("Read back converted textures unsupported\n");
  59              return;
  60          }
  61
  62         if (This->Flags & SFLAG_NONPOW2) {
  63             unsigned char alignment = This->resource.wineD3DDevice->surface_alignment;
  64             src_pitch = This->bytesPerPixel * This->pow2Width;
  65             dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
  66             src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
  67             mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
  68         } else {
  69             mem = This->resource.allocatedMemory;
  70         }
  71
  72         TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n", This, This->glDescription.level,
  73                 This->glDescription.glFormat, This->glDescription.glType, mem);
  74
  75         if(This->Flags & SFLAG_PBO) {
  76             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
  77             checkGLcall("glBindBufferARB");
  78
  79             glGetTexImage(This->glDescription.target, This->glDescription.level, This->glDescription.glFormat,
  80                           This->glDescription.glType, NULL);
  81             checkGLcall("glGetTexImage()");
  82
  83             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
  84             checkGLcall("glBindBufferARB");
  85         } else {
  86             glGetTexImage(This->glDescription.target, This->glDescription.level, This->glDescription.glFormat,
  87                           This->glDescription.glType, mem);
  88             checkGLcall("glGetTexImage()");
  89         }
  90
  91         if (This->Flags & SFLAG_NONPOW2) {
  92             LPBYTE src_data, dst_data;
  93             int y;
  94             /*
  95              * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
  96              * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
  97              * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
  98              *
  99              * We're doing this...
 100              *
 101              * instead of boxing the texture :
 102              * |<-texture width ->|  -->pow2width|   /\
 103              * |111111111111111111|              |   |
 104              * |222 Texture 222222| boxed empty  | texture height
 105              * |3333 Data 33333333|              |   |
 106              * |444444444444444444|              |   \/
 107              * -----------------------------------   |
 108              * |     boxed  empty | boxed empty  | pow2height
 109              * |                  |              |   \/
 110              * -----------------------------------
 111              *
 112              *
 113              * we're repacking the data to the expected texture width
 114              *
 115              * |<-texture width ->|  -->pow2width|   /\
 116              * |111111111111111111222222222222222|   |
 117              * |222333333333333333333444444444444| texture height
 118              * |444444                           |   |
 119              * |                                 |   \/
 120              * |                                 |   |
 121              * |            empty                | pow2height
 122              * |                                 |   \/
 123              * -----------------------------------
 124              *
 125              * == is the same as
 126              *
 127              * |<-texture width ->|    /\
 128              * |111111111111111111|
 129              * |222222222222222222|texture height
 130              * |333333333333333333|
 131              * |444444444444444444|    \/
 132              * --------------------
 133              *
 134              * this also means that any references to allocatedMemory should work with the data as if were a
 135              * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
 136              *
 137              * internally the texture is still stored in a boxed format so any references to textureName will
 138              * get a boxed texture with width pow2width and not a texture of width currentDesc.Width.
 139              *
 140              * Performance should not be an issue, because applications normally do not lock the surfaces when
 141              * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
 142              * and doesn't have to be re-read.
 143              */
 144             src_data = mem;
 145             dst_data = This->resource.allocatedMemory;
 146             TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This, src_pitch, dst_pitch);
 147             for (y = 1 ; y < This->currentDesc.Height; y++) {
 148                 /* skip the first row */
 149                 src_data += src_pitch;
 150                 dst_data += dst_pitch;
 151                 memcpy(dst_data, src_data, dst_pitch);
 152             }
 153
 154             HeapFree(GetProcessHeap(), 0, mem);
 155         }
 156     }
 157     /* Surface has now been downloaded */
 158     This->Flags |= SFLAG_INSYSMEM;
 159 }
 160
 161 static void surface_upload_data(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *data) {
 162     if (This->resource.format == WINED3DFMT_DXT1 ||
 163             This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 ||
 164             This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) {
 165         if (!GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
 166             FIXME("Using DXT1/3/5 without advertized support\n");
 167         } else {
 168             if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
 169                 /* Neither NONPOW2, DIBSECTION nor OVERSIZE flags can be set on compressed textures */
 170                 This->Flags |= SFLAG_CLIENT;
 171             }
 172
 173             /* glCompressedTexSubImage2D for uploading and glTexImage2D for allocating does not work well on some drivers(r200 dri, MacOS ATI driver)
 174              * glCompressedTexImage2D does not accept NULL pointers. So for compressed textures surface_allocate_surface does nothing, and this
 175              * function uses glCompressedTexImage2D instead of the SubImage call
 176              */
 177             TRACE("(%p) : Calling glCompressedTexSubImage2D w %d, h %d, data %p\n", This, width, height, data);
 178             ENTER_GL();
 179
 180             if(This->Flags & SFLAG_PBO) {
 181                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 182                 checkGLcall("glBindBufferARB");
 183                 TRACE("(%p) pbo: %#x, data: %p\n", This, This->pbo, data);
 184
 185                 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
 186                         width, height, 0 /* border */, This->resource.size, NULL));
 187                 checkGLcall("glCompressedTexSubImage2D");
 188
 189                 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 190                 checkGLcall("glBindBufferARB");
 191             } else {
 192                 GL_EXTCALL(glCompressedTexImage2DARB(This->glDescription.target, This->glDescription.level, internal,
 193                         width, height, 0 /* border */, This->resource.size, data));
 194                 checkGLcall("glCompressedTexSubImage2D");
 195             }
 196             LEAVE_GL();
 197         }
 198     } else {
 199         TRACE("(%p) : Calling glTexSubImage2D w %d,  h %d, data, %p\n", This, width, height, data);
 200         ENTER_GL();
 201
 202         if(This->Flags & SFLAG_PBO) {
 203             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 204             checkGLcall("glBindBufferARB");
 205             TRACE("(%p) pbo: %#x, data: %p\n", This, This->pbo, data);
 206
 207             glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, NULL);
 208             checkGLcall("glTexSubImage2D");
 209
 210             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 211             checkGLcall("glBindBufferARB");
 212         }
 213         else {
 214             glTexSubImage2D(This->glDescription.target, This->glDescription.level, 0, 0, width, height, format, type, data);
 215             checkGLcall("glTexSubImage2D");
 216         }
 217
 218         LEAVE_GL();
 219     }
 220 }
 221
 222 static void surface_allocate_surface(IWineD3DSurfaceImpl *This, GLenum internal, GLsizei width, GLsizei height, GLenum format, GLenum type) {
 223     BOOL enable_client_storage = FALSE;
 224
 225     TRACE("(%p) : Creating surface (target %#x)  level %d, d3d format %s, internal format %#x, width %d, height %d, gl format %#x, gl type=%#x\n", This,
 226             This->glDescription.target, This->glDescription.level, debug_d3dformat(This->resource.format), internal, width, height, format, type);
 227
 228     if (This->resource.format == WINED3DFMT_DXT1 ||
 229             This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3 ||
 230             This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) {
 231         /* glCompressedTexImage2D does not accept NULL pointers, so we cannot allocate a compressed texture without uploading data */
 232         TRACE("Not allocating compressed surfaces, surface_upload_data will specify them\n");
 233         return;
 234     }
 235
 236     ENTER_GL();
 237
 238     if(GL_SUPPORT(APPLE_CLIENT_STORAGE)) {
 239         if(This->Flags & (SFLAG_NONPOW2 | SFLAG_DIBSECTION | SFLAG_OVERSIZE | SFLAG_CONVERTED) || This->resource.allocatedMemory == NULL) {
 240             /* In some cases we want to disable client storage.
 241              * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
 242              * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
 243              * SFLAG_OVERSIZE: The gl texture is smaller than the allocated memory
 244              * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
 245              * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
 246              */
 247             glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
 248             checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
 249             This->Flags &= SFLAG_CLIENT;
 250             enable_client_storage = TRUE;
 251         } else {
 252             This->Flags |= SFLAG_CLIENT;
 253             /* Below point opengl to our allocated texture memory */
 254         }
 255     }
 256     glTexImage2D(This->glDescription.target, This->glDescription.level, internal, width, height, 0, format, type,
 257                  This->Flags & SFLAG_CLIENT ? This->resource.allocatedMemory : NULL);
 258     checkGLcall("glTexImage2D");
 259
 260     if(enable_client_storage) {
 261         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
 262         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
 263     }
 264     LEAVE_GL();
 265
 266     This->Flags |= SFLAG_ALLOCATED;
 267 }
 268
 269 /* In D3D the depth stencil dimensions have to be greater than or equal to the
 270  * render target dimensions. With FBOs, the dimensions have to be an exact match. */
 271 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
 272 void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height) {
 273     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 274     renderbuffer_entry_t *entry;
 275     GLuint renderbuffer = 0;
 276     unsigned int src_width, src_height;
 277
 278     src_width = This->pow2Width;
 279     src_height = This->pow2Height;
 280
 281     /* A depth stencil smaller than the render target is not valid */
 282     if (width > src_width || height > src_height) return;
 283
 284     /* Remove any renderbuffer set if the sizes match */
 285     if (width == src_width && height == src_height) {
 286         This->current_renderbuffer = NULL;
 287         return;
 288     }
 289
 290     /* Look if we've already got a renderbuffer of the correct dimensions */
 291     LIST_FOR_EACH_ENTRY(entry, &This->renderbuffers, renderbuffer_entry_t, entry) {
 292         if (entry->width == width && entry->height == height) {
 293             renderbuffer = entry->id;
 294             This->current_renderbuffer = entry;
 295             break;
 296         }
 297     }
 298
 299     if (!renderbuffer) {
 300         const GlPixelFormatDesc *glDesc;
 301         getFormatDescEntry(This->resource.format, &GLINFO_LOCATION, &glDesc);
 302
 303         GL_EXTCALL(glGenRenderbuffersEXT(1, &renderbuffer));
 304         GL_EXTCALL(glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, renderbuffer));
 305         GL_EXTCALL(glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, glDesc->glFormat, width, height));
 306
 307         entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
 308         entry->width = width;
 309         entry->height = height;
 310         entry->id = renderbuffer;
 311         list_add_head(&This->renderbuffers, &entry->entry);
 312
 313         This->current_renderbuffer = entry;
 314     }
 315
 316     checkGLcall("set_compatible_renderbuffer");
 317 }
 318
 319 GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain) {
 320     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 321     IWineD3DSwapChainImpl *swapchain_impl = (IWineD3DSwapChainImpl *)swapchain;
 322
 323     TRACE("(%p) : swapchain %p\n", This, swapchain);
 324
 325     if (swapchain_impl->backBuffer && swapchain_impl->backBuffer[0] == iface) {
 326         TRACE("Returning GL_BACK\n");
 327         return GL_BACK;
 328     } else if (swapchain_impl->frontBuffer == iface) {
 329         TRACE("Returning GL_FRONT\n");
 330         return GL_FRONT;
 331     }
 332
 333     FIXME("Higher back buffer, returning GL_BACK\n");
 334     return GL_BACK;
 335 }
 336
 337 ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface) {
 338     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 339     ULONG ref = InterlockedDecrement(&This->resource.ref);
 340     TRACE("(%p) : Releasing from %d\n", This, ref + 1);
 341     if (ref == 0) {
 342         IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->resource.wineD3DDevice;
 343         renderbuffer_entry_t *entry, *entry2;
 344         TRACE("(%p) : cleaning up\n", This);
 345
 346         if(iface == device->lastActiveRenderTarget) {
 347             IWineD3DSwapChainImpl *swapchain = device->swapchains ? (IWineD3DSwapChainImpl *) device->swapchains[0] : NULL;
 348
 349             TRACE("Last active render target destroyed\n");
 350             /* Find a replacement surface for the currently active back buffer. The context manager does not do NULL
 351              * checks, so switch to a valid target as long as the currently set surface is still valid. Use the
 352              * surface of the implicit swpchain. If that is the same as the destroyed surface the device is destroyed
 353              * and the lastActiveRenderTarget member shouldn't matter
 354              */
 355             if(swapchain) {
 356                 if(swapchain->backBuffer && swapchain->backBuffer[0] != iface) {
 357                     TRACE("Activating primary back buffer\n");
 358                     ActivateContext(device, swapchain->backBuffer[0], CTXUSAGE_RESOURCELOAD);
 359                 } else if(!swapchain->backBuffer && swapchain->frontBuffer != iface) {
 360                     /* Single buffering environment */
 361                     TRACE("Activating primary front buffer\n");
 362                     ActivateContext(device, swapchain->frontBuffer, CTXUSAGE_RESOURCELOAD);
 363                 } else {
 364                     TRACE("Device is being destroyed, setting lastActiveRenderTarget = 0xdeadbabe\n");
 365                     /* Implicit render target destroyed, that means the device is being destroyed
 366                      * whatever we set here, it shouldn't matter
 367                      */
 368                     device->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadbabe;
 369                 }
 370             } else {
 371                 /* May happen during ddraw uninitialization */
 372                 TRACE("Render target set, but swapchain does not exist!\n");
 373                 device->lastActiveRenderTarget = (IWineD3DSurface *) 0xdeadcafe;
 374             }
 375         }
 376
 377         if (This->glDescription.textureName != 0) { /* release the openGL texture.. */
 378
 379             /* Need a context to destroy the texture. Use the currently active render target, but only if
 380              * the primary render target exists. Otherwise lastActiveRenderTarget is garbage, see above.
 381              * When destroying the primary rt, Uninit3D will activate a context before doing anything
 382              */
 383             if(device->render_targets && device->render_targets[0]) {
 384                 ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 385             }
 386
 387             TRACE("Deleting texture %d\n", This->glDescription.textureName);
 388             ENTER_GL();
 389             glDeleteTextures(1, &This->glDescription.textureName);
 390             LEAVE_GL();
 391         }
 392
 393         if(This->Flags & SFLAG_PBO) {
 394             /* Delete the PBO */
 395             GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
 396         }
 397
 398         if(This->Flags & SFLAG_DIBSECTION) {
 399             /* Release the DC */
 400             SelectObject(This->hDC, This->dib.holdbitmap);
 401             DeleteDC(This->hDC);
 402             /* Release the DIB section */
 403             DeleteObject(This->dib.DIBsection);
 404             This->dib.bitmap_data = NULL;
 405             This->resource.allocatedMemory = NULL;
 406         }
 407         if(This->Flags & SFLAG_USERPTR) IWineD3DSurface_SetMem(iface, NULL);
 408
 409         HeapFree(GetProcessHeap(), 0, This->palette9);
 410
 411         IWineD3DResourceImpl_CleanUp((IWineD3DResource *)iface);
 412         if(iface == device->ddraw_primary)
 413             device->ddraw_primary = NULL;
 414
 415         LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry) {
 416             GL_EXTCALL(glDeleteRenderbuffersEXT(1, &entry->id));
 417             HeapFree(GetProcessHeap(), 0, entry);
 418         }
 419
 420         TRACE("(%p) Released\n", This);
 421         HeapFree(GetProcessHeap(), 0, This);
 422
 423     }
 424     return ref;
 425 }
 426
 427 /* ****************************************************
 428    IWineD3DSurface IWineD3DResource parts follow
 429    **************************************************** */
 430
 431 void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface) {
 432     /* TODO: check for locks */
 433     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 434     IWineD3DBaseTexture *baseTexture = NULL;
 435     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
 436
 437     TRACE("(%p)Checking to see if the container is a base texture\n", This);
 438     if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
 439         TRACE("Passing to container\n");
 440         IWineD3DBaseTexture_PreLoad(baseTexture);
 441         IWineD3DBaseTexture_Release(baseTexture);
 442     } else {
 443     TRACE("(%p) : About to load surface\n", This);
 444
 445     if(!device->isInDraw) {
 446         ActivateContext(device, device->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 447     }
 448
 449     ENTER_GL();
 450     glEnable(This->glDescription.target);/* make sure texture support is enabled in this context */
 451     if (!This->glDescription.level) {
 452         if (!This->glDescription.textureName) {
 453             glGenTextures(1, &This->glDescription.textureName);
 454             checkGLcall("glGenTextures");
 455             TRACE("Surface %p given name %d\n", This, This->glDescription.textureName);
 456         }
 457         glBindTexture(This->glDescription.target, This->glDescription.textureName);
 458         checkGLcall("glBindTexture");
 459         IWineD3DSurface_LoadTexture(iface, FALSE);
 460         /* This is where we should be reducing the amount of GLMemoryUsed */
 461     } else if (This->glDescription.textureName) { /* NOTE: the level 0 surface of a mpmapped texture must be loaded first! */
 462         /* assume this is a coding error not a real error for now */
 463         FIXME("Mipmap surface has a glTexture bound to it!\n");
 464     }
 465     if (This->resource.pool == WINED3DPOOL_DEFAULT) {
 466        /* Tell opengl to try and keep this texture in video ram (well mostly) */
 467        GLclampf tmp;
 468        tmp = 0.9f;
 469         glPrioritizeTextures(1, &This->glDescription.textureName, &tmp);
 470     }
 471     LEAVE_GL();
 472     }
 473     return;
 474 }
 475
 476 /* ******************************************************
 477    IWineD3DSurface IWineD3DSurface parts follow
 478    ****************************************************** */
 479
 480 void WINAPI IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface *iface, UINT textureName, int target) {
 481     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 482     TRACE("(%p) : setting textureName %u, target %i\n", This, textureName, target);
 483     if (This->glDescription.textureName == 0 && textureName != 0) {
 484         This->Flags &= ~SFLAG_INTEXTURE;
 485         IWineD3DSurface_AddDirtyRect(iface, NULL);
 486     }
 487     This->glDescription.textureName = textureName;
 488     This->glDescription.target      = target;
 489     This->Flags &= ~SFLAG_ALLOCATED;
 490 }
 491
 492 void WINAPI IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription) {
 493     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 494     TRACE("(%p) : returning %p\n", This, &This->glDescription);
 495     *glDescription = &This->glDescription;
 496 }
 497
 498 /* TODO: think about moving this down to resource? */
 499 const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface) {
 500     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 501     /* This should only be called for sysmem textures, it may be a good idea to extend this to all pools at some point in the future  */
 502     if (This->resource.pool != WINED3DPOOL_SYSTEMMEM) {
 503         FIXME(" (%p)Attempting to get system memory for a non-system memory texture\n", iface);
 504     }
 505     return (CONST void*)(This->resource.allocatedMemory);
 506 }
 507
 508 static void read_from_framebuffer(IWineD3DSurfaceImpl *This, CONST RECT *rect, void *dest, UINT pitch, BOOL srcUpsideDown) {
 509     BYTE *mem;
 510     GLint fmt;
 511     GLint type;
 512     BYTE *row, *top, *bottom;
 513     int i;
 514     BOOL bpp;
 515
 516     switch(This->resource.format)
 517     {
 518         case WINED3DFMT_P8:
 519         {
 520             /* GL can't return palettized data, so read ARGB pixels into a
 521              * separate block of memory and convert them into palettized format
 522              * in software. Slow, but if the app means to use palettized render
 523              * targets and locks it...
 524              *
 525              * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
 526              * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
 527              * for the color channels when palettizing the colors.
 528              */
 529             fmt = GL_RGB;
 530             type = GL_UNSIGNED_BYTE;
 531             pitch *= 3;
 532             mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * 3);
 533             if(!mem) {
 534                 ERR("Out of memory\n");
 535                 return;
 536             }
 537             bpp = This->bytesPerPixel * 3;
 538         }
 539         break;
 540
 541         default:
 542             mem = dest;
 543             fmt = This->glDescription.glFormat;
 544             type = This->glDescription.glType;
 545             bpp = This->bytesPerPixel;
 546     }
 547
 548     if(This->Flags & SFLAG_PBO) {
 549         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 550         checkGLcall("glBindBufferARB");
 551     }
 552
 553     glReadPixels(rect->left, rect->top,
 554                  rect->right - rect->left,
 555                  rect->bottom - rect->top,
 556                  fmt, type, mem);
 557     vcheckGLcall("glReadPixels");
 558
 559     if(This->Flags & SFLAG_PBO) {
 560         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 561         checkGLcall("glBindBufferARB");
 562
 563         /* Check if we need to flip the image. If we need to flip use glMapBufferARB
 564          * to get a pointer to it and perform the flipping in software. This is a lot
 565          * faster than calling glReadPixels for each line. In case we want more speed
 566          * we should rerender it flipped in a FBO and read the data back from the FBO. */
 567         if(!srcUpsideDown) {
 568             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 569             checkGLcall("glBindBufferARB");
 570
 571             mem = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
 572             checkGLcall("glMapBufferARB");
 573         }
 574     }
 575
 576     /* TODO: Merge this with the palettization loop below for P8 targets */
 577     if(!srcUpsideDown) {
 578         UINT len, off;
 579         /* glReadPixels returns the image upside down, and there is no way to prevent this.
 580             Flip the lines in software */
 581         len = (rect->right - rect->left) * bpp;
 582         off = rect->left * bpp;
 583
 584         row = HeapAlloc(GetProcessHeap(), 0, len);
 585         if(!row) {
 586             ERR("Out of memory\n");
 587             if(This->resource.format == WINED3DFMT_P8) HeapFree(GetProcessHeap(), 0, mem);
 588             return;
 589         }
 590
 591         top = mem + pitch * rect->top;
 592         bottom = ((BYTE *) mem) + pitch * ( rect->bottom - rect->top - 1);
 593         for(i = 0; i < (rect->bottom - rect->top) / 2; i++) {
 594             memcpy(row, top + off, len);
 595             memcpy(top + off, bottom + off, len);
 596             memcpy(bottom + off, row, len);
 597             top += pitch;
 598             bottom -= pitch;
 599         }
 600         HeapFree(GetProcessHeap(), 0, row);
 601
 602         /* Unmap the temp PBO buffer */
 603         if(This->Flags & SFLAG_PBO) {
 604             GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
 605             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 606         }
 607     }
 608
 609     if(This->resource.format == WINED3DFMT_P8) {
 610         PALETTEENTRY *pal;
 611         DWORD width = pitch / 3;
 612         int x, y, c;
 613         if(This->palette) {
 614             pal = This->palette->palents;
 615         } else {
 616             pal = This->resource.wineD3DDevice->palettes[This->resource.wineD3DDevice->currentPalette];
 617         }
 618
 619         for(y = rect->top; y < rect->bottom; y++) {
 620             for(x = rect->left; x < rect->right; x++) {
 621                 /*                      start              lines            pixels      */
 622                 BYTE *blue =  (BYTE *) ((BYTE *) mem) + y * pitch + x * (sizeof(BYTE) * 3);
 623                 BYTE *green = blue  + 1;
 624                 BYTE *red =   green + 1;
 625
 626                 for(c = 0; c < 256; c++) {
 627                     if(*red   == pal[c].peRed   &&
 628                        *green == pal[c].peGreen &&
 629                        *blue  == pal[c].peBlue)
 630                     {
 631                         *((BYTE *) dest + y * width + x) = c;
 632                         break;
 633                     }
 634                 }
 635             }
 636         }
 637         HeapFree(GetProcessHeap(), 0, mem);
 638     }
 639 }
 640
 641 static HRESULT WINAPI IWineD3DSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags) {
 642     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
 643     IWineD3DDeviceImpl  *myDevice = This->resource.wineD3DDevice;
 644     IWineD3DSwapChainImpl *swapchain = NULL;
 645
 646     TRACE("(%p) : rect@%p flags(%08x), output lockedRect@%p, memory@%p\n", This, pRect, Flags, pLockedRect, This->resource.allocatedMemory);
 647
 648     if (This->Flags & SFLAG_LOCKED) {
 649         WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
 650         return WINED3DERR_INVALIDCALL;
 651     }
 652     if (!(This->Flags & SFLAG_LOCKABLE)) {
 653         /* Note: UpdateTextures calls CopyRects which calls this routine to populate the
 654               texture regions, and since the destination is an unlockable region we need
 655               to tolerate this                                                           */
 656         TRACE("Warning: trying to lock unlockable surf@%p\n", This);
 657         /*return WINED3DERR_INVALIDCALL; */
 658     }
 659
 660     pLockedRect->Pitch = IWineD3DSurface_GetPitch(iface);
 661
 662     /* Mark the surface locked */
 663     This->Flags |= SFLAG_LOCKED;
 664
 665     /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
 666      * or a pbo to map
 667      */
 668     if(!(This->resource.allocatedMemory || This->Flags & SFLAG_PBO)) {
 669         This->resource.allocatedMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + 4);
 670         This->Flags &= ~SFLAG_INSYSMEM; /* This is the marker that surface data has to be downloaded */
 671     }
 672
 673     /* Create a PBO for dynamicly locked surfaces but don't do it for converted or non-pow2 surfaces.
 674      * Also don't create a PBO for systemmem surfaces. */
 675     if(GL_SUPPORT(ARB_PIXEL_BUFFER_OBJECT) && (This->Flags & SFLAG_DYNLOCK) && !(This->Flags & (SFLAG_PBO | SFLAG_CONVERTED | SFLAG_NONPOW2)) && (This->resource.pool != WINED3DPOOL_SYSTEMMEM)) {
 676         GLenum error;
 677         ENTER_GL();
 678
 679         GL_EXTCALL(glGenBuffersARB(1, &This->pbo));
 680         error = glGetError();
 681         if(This->pbo == 0 || error != GL_NO_ERROR) {
 682             ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error), error);
 683         }
 684
 685         TRACE("Attaching pbo=%#x to (%p)\n", This->pbo, This);
 686
 687         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 688         checkGLcall("glBindBufferARB");
 689
 690         GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->resource.size + 4, This->resource.allocatedMemory, GL_STREAM_DRAW_ARB));
 691         checkGLcall("glBufferDataARB");
 692
 693         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 694         checkGLcall("glBindBufferARB");
 695
 696         /* We don't need the system memory anymore and we can't even use it for PBOs */
 697         HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
 698         This->resource.allocatedMemory = NULL;
 699         This->Flags |= SFLAG_PBO;
 700         LEAVE_GL();
 701     }
 702
 703     /* Calculate the correct start address to report */
 704     if (NULL == pRect) {
 705         This->lockedRect.left   = 0;
 706         This->lockedRect.top    = 0;
 707         This->lockedRect.right  = This->currentDesc.Width;
 708         This->lockedRect.bottom = This->currentDesc.Height;
 709         TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n", &This->lockedRect, This->lockedRect.left, This->lockedRect.top, This->lockedRect.right, This->lockedRect.bottom);
 710     } else {
 711         This->lockedRect.left   = pRect->left;
 712         This->lockedRect.top    = pRect->top;
 713         This->lockedRect.right  = pRect->right;
 714         This->lockedRect.bottom = pRect->bottom;
 715         TRACE("Locked Rect (%p) = l %d, t %d, r %d, b %d\n", pRect, pRect->left, pRect->top, pRect->right, pRect->bottom);
 716     }
 717
 718     if (This->Flags & SFLAG_NONPOW2) {
 719         TRACE("Locking non-power 2 texture\n");
 720     }
 721
 722     /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
 723      * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
 724      * changed
 725      */
 726     if(!(This->Flags & SFLAG_DYNLOCK)) {
 727         This->lockCount++;
 728         /* MAXLOCKCOUNT is defined in wined3d_private.h */
 729         if(This->lockCount > MAXLOCKCOUNT) {
 730             TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
 731             This->Flags |= SFLAG_DYNLOCK;
 732         }
 733     }
 734
 735     if (Flags & WINED3DLOCK_DISCARD) {
 736         /* Set SFLAG_INSYSMEM, so we'll never try to download the data from the texture. */
 737         TRACE("WINED3DLOCK_DISCARD flag passed, marking local copy as up to date\n");
 738         This->Flags |= SFLAG_INSYSMEM;
 739     }
 740
 741     if (This->Flags & SFLAG_INSYSMEM) {
 742         TRACE("Local copy is up to date, not downloading data\n");
 743         goto lock_end;
 744     }
 745
 746     /* Now download the surface content from opengl
 747      * Use the render target readback if the surface is on a swapchain(=onscreen render target) or the current primary target
 748      * Offscreen targets which are not active at the moment or are higher targets(fbos) can be locked with the texture path
 749      */
 750     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain);
 751     if(swapchain || iface == myDevice->render_targets[0]) {
 752         BOOL srcIsUpsideDown;
 753
 754         if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
 755             static BOOL warned = FALSE;
 756             if(!warned) {
 757                 ERR("The application tries to lock the render target, but render target locking is disabled\n");
 758                 warned = TRUE;
 759             }
 760             if(swapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
 761             return WINED3D_OK;
 762         }
 763
 764         /* Activate the surface. Set it up for blitting now, although not necessarily needed for LockRect.
 765          * Certain graphics drivers seem to dislike some enabled states when reading from opengl, the blitting usage
 766          * should help here. Furthermore unlockrect will need the context set up for blitting. The context manager will find
 767          * context->last_was_blit set on the unlock.
 768          */
 769         ActivateContext(myDevice, iface, CTXUSAGE_BLIT);
 770         ENTER_GL();
 771
 772         /* Select the correct read buffer, and give some debug output.
 773          * There is no need to keep track of the current read buffer or reset it, every part of the code
 774          * that reads sets the read buffer as desired.
 775          */
 776         if(!swapchain) {
 777             /* Locking the primary render target which is not on a swapchain(=offscreen render target).
 778              * Read from the back buffer
 779              */
 780             TRACE("Locking offscreen render target\n");
 781             glReadBuffer(myDevice->offscreenBuffer);
 782             srcIsUpsideDown = TRUE;
 783         } else {
 784             GLenum buffer = surface_get_gl_buffer(iface, (IWineD3DSwapChain *)swapchain);
 785             TRACE("Locking %#x buffer\n", buffer);
 786             glReadBuffer(buffer);
 787             checkGLcall("glReadBuffer");
 788
 789             IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
 790             srcIsUpsideDown = FALSE;
 791         }
 792
 793         switch(wined3d_settings.rendertargetlock_mode) {
 794             case RTL_AUTO:
 795             case RTL_READDRAW:
 796             case RTL_READTEX:
 797                 read_from_framebuffer(This, &This->lockedRect, This->resource.allocatedMemory, pLockedRect->Pitch, srcIsUpsideDown);
 798                 break;
 799
 800             case RTL_TEXDRAW:
 801             case RTL_TEXTEX:
 802                 read_from_framebuffer(This, &This->lockedRect, This->resource.allocatedMemory, pLockedRect->Pitch, srcIsUpsideDown);
 803                 FIXME("Reading from render target with a texture isn't implemented yet, falling back to framebuffer reading\n");
 804                 break;
 805         }
 806
 807         LEAVE_GL();
 808
 809         /* Mark the local copy up to date if a full download was done */
 810         if(This->lockedRect.left == 0 &&
 811            This->lockedRect.top == 0 &&
 812            This->lockedRect.right == This->currentDesc.Width &&
 813            This->lockedRect.bottom == This->currentDesc.Height) {
 814             This->Flags |= SFLAG_INSYSMEM;
 815         }
 816     } else if(iface == myDevice->stencilBufferTarget) {
 817         /** the depth stencil in openGL has a format of GL_FLOAT
 818          * which should be good for WINED3DFMT_D16_LOCKABLE
 819          * and WINED3DFMT_D16
 820          * it is unclear what format the stencil buffer is in except.
 821          * 'Each index is converted to fixed point...
 822          * If GL_MAP_STENCIL is GL_TRUE, indices are replaced by their
 823          * mappings in the table GL_PIXEL_MAP_S_TO_S.
 824          * glReadPixels(This->lockedRect.left,
 825          *             This->lockedRect.bottom - j - 1,
 826          *             This->lockedRect.right - This->lockedRect.left,
 827          *             1,
 828          *             GL_DEPTH_COMPONENT,
 829          *             type,
 830          *             (char *)pLockedRect->pBits + (pLockedRect->Pitch * (j-This->lockedRect.top)));
 831          *
 832          * Depth Stencil surfaces which are not the current depth stencil target should have their data in a
 833          * gl texture(next path), or in local memory(early return because of set SFLAG_INSYSMEM above). If
 834          * none of that is the case the problem is not in this function :-)
 835          ********************************************/
 836         FIXME("Depth stencil locking not supported yet\n");
 837     } else {
 838         /* This path is for normal surfaces, offscreen render targets and everything else that is in a gl texture */
 839         TRACE("locking an ordinary surface\n");
 840
 841         if (0 != This->glDescription.textureName) {
 842             /* Now I have to copy thing bits back */
 843
 844             if(myDevice->createParms.BehaviorFlags & WINED3DCREATE_MULTITHREADED) {
 845                 ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 846             }
 847
 848             ENTER_GL();
 849             /* Make sure that a proper texture unit is selected, bind the texture and dirtify the sampler to restore the texture on the next draw */
 850             if (GL_SUPPORT(ARB_MULTITEXTURE)) {
 851                 GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
 852                 checkGLcall("glActiveTextureARB");
 853             }
 854             IWineD3DDeviceImpl_MarkStateDirty(This->resource.wineD3DDevice, STATE_SAMPLER(0));
 855             IWineD3DSurface_PreLoad(iface);
 856
 857             surface_download_data(This);
 858             LEAVE_GL();
 859         }
 860     }
 861
 862 lock_end:
 863     if(This->Flags & SFLAG_PBO) {
 864         ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
 865         ENTER_GL();
 866         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 867         checkGLcall("glBindBufferARB");
 868
 869         /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
 870         if(This->resource.allocatedMemory) {
 871             ERR("The surface already has PBO memory allocated!\n");
 872         }
 873
 874         This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
 875         checkGLcall("glMapBufferARB");
 876
 877         /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
 878         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
 879         checkGLcall("glBindBufferARB");
 880
 881         LEAVE_GL();
 882     }
 883
 884     /* Calculate the correct start address to report */
 885     if (NULL == pRect) {
 886         pLockedRect->pBits = This->resource.allocatedMemory;
 887     } else {
 888         /* DXTn textures are based on compressed blocks of 4x4 pixels, each
 889          * 16 bytes large (8 bytes in case of DXT1). Because of that Pitch has
 890          * slightly different meaning compared to regular textures. For DXTn
 891          * textures Pitch is the size of a row of blocks, 4 high and "width"
 892          * long. The x offset is calculated differently as well, since moving 4
 893          * pixels to the right actually moves an entire 4x4 block to right, ie
 894          * 16 bytes (8 in case of DXT1). */
 895         if (This->resource.format == WINED3DFMT_DXT1) {
 896             pLockedRect->pBits = This->resource.allocatedMemory + (pLockedRect->Pitch * pRect->top / 4) + (pRect->left * 2);
 897         } else if (This->resource.format == WINED3DFMT_DXT2 || This->resource.format == WINED3DFMT_DXT3
 898                 || This->resource.format == WINED3DFMT_DXT4 || This->resource.format == WINED3DFMT_DXT5) {
 899             pLockedRect->pBits = This->resource.allocatedMemory + (pLockedRect->Pitch * pRect->top / 4) + (pRect->left * 4);
 900         } else {
 901             pLockedRect->pBits = This->resource.allocatedMemory + (pLockedRect->Pitch * pRect->top) + (pRect->left * This->bytesPerPixel);
 902         }
 903     }
 904
 905     if (Flags & (WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY)) {
 906         /* Don't dirtify */
 907     } else {
 908         IWineD3DBaseTexture *pBaseTexture;
 909         /**
 910          * Dirtify on lock
 911          * as seen in msdn docs
 912          */
 913         IWineD3DSurface_AddDirtyRect(iface, &This->lockedRect);
 914
 915         /** Dirtify Container if needed */
 916         if (WINED3D_OK == IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&pBaseTexture) && pBaseTexture != NULL) {
 917             TRACE("Making container dirty\n");
 918             IWineD3DBaseTexture_SetDirty(pBaseTexture, TRUE);
 919             IWineD3DBaseTexture_Release(pBaseTexture);
 920         } else {
 921             TRACE("Surface is standalone, no need to dirty the container\n");
 922         }
 923     }
 924
 925     TRACE("returning memory@%p, pitch(%d) dirtyfied(%d)\n", pLockedRect->pBits, pLockedRect->Pitch,
 926           This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
 927     return WINED3D_OK;
 928 }
 929
 930 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *This) {
 931     GLint  prev_store;
 932     GLint  prev_rasterpos[4];
 933     GLint skipBytes = 0;
 934     BOOL storechanged = FALSE, memory_allocated = FALSE;
 935     GLint fmt, type;
 936     BYTE *mem;
 937     UINT bpp;
 938     UINT pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);    /* target is argb, 4 byte */
 939
 940     glDisable(GL_TEXTURE_2D);
 941     vcheckGLcall("glDisable(GL_TEXTURE_2D)");
 942
 943     glFlush();
 944     vcheckGLcall("glFlush");
 945     glGetIntegerv(GL_PACK_SWAP_BYTES, &prev_store);
 946     vcheckGLcall("glIntegerv");
 947     glGetIntegerv(GL_CURRENT_RASTER_POSITION, &prev_rasterpos[0]);
 948     vcheckGLcall("glIntegerv");
 949     glPixelZoom(1.0, -1.0);
 950     vcheckGLcall("glPixelZoom");
 951
 952     /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
 953     glGetIntegerv(GL_UNPACK_ROW_LENGTH, &skipBytes);
 954     glPixelStorei(GL_UNPACK_ROW_LENGTH, This->currentDesc.Width);
 955
 956     glRasterPos3i(This->lockedRect.left, This->lockedRect.top, 1);
 957     vcheckGLcall("glRasterPos2f");
 958
 959     /* Some drivers(radeon dri, others?) don't like exceptions during
 960      * glDrawPixels. If the surface is a DIB section, it might be in GDIMode
 961      * after ReleaseDC. Reading it will cause an exception, which x11drv will
 962      * catch to put the dib section in InSync mode, which leads to a crash
 963      * and a blocked x server on my radeon card.
 964      *
 965      * The following lines read the dib section so it is put in inSync mode
 966      * before glDrawPixels is called and the crash is prevented. There won't
 967      * be any interfering gdi accesses, because UnlockRect is called from
 968      * ReleaseDC, and the app won't use the dc any more afterwards.
 969      */
 970     if((This->Flags & SFLAG_DIBSECTION) && !(This->Flags & SFLAG_PBO)) {
 971         volatile BYTE read;
 972         read = This->resource.allocatedMemory[0];
 973     }
 974
 975     switch (This->resource.format) {
 976         /* No special care needed */
 977         case WINED3DFMT_A4R4G4B4:
 978         case WINED3DFMT_R5G6B5:
 979         case WINED3DFMT_A1R5G5B5:
 980         case WINED3DFMT_R8G8B8:
 981             type = This->glDescription.glType;
 982             fmt = This->glDescription.glFormat;
 983             mem = This->resource.allocatedMemory;
 984             bpp = This->bytesPerPixel;
 985             break;
 986
 987         case WINED3DFMT_X4R4G4B4:
 988         {
 989             int size;
 990             unsigned short *data;
 991             data = (unsigned short *)This->resource.allocatedMemory;
 992             size = (This->lockedRect.bottom - This->lockedRect.top) * (This->lockedRect.right - This->lockedRect.left);
 993             while(size > 0) {
 994                 *data |= 0xF000;
 995                 data++;
 996                 size--;
 997             }
 998             type = This->glDescription.glType;
 999             fmt = This->glDescription.glFormat;
1000             mem = This->resource.allocatedMemory;
1001             bpp = This->bytesPerPixel;
1002         }
1003         break;
1004
1005         case WINED3DFMT_X1R5G5B5:
1006         {
1007             int size;
1008             unsigned short *data;
1009             data = (unsigned short *)This->resource.allocatedMemory;
1010             size = (This->lockedRect.bottom - This->lockedRect.top) * (This->lockedRect.right - This->lockedRect.left);
1011             while(size > 0) {
1012                 *data |= 0x8000;
1013                 data++;
1014                 size--;
1015             }
1016             type = This->glDescription.glType;
1017             fmt = This->glDescription.glFormat;
1018             mem = This->resource.allocatedMemory;
1019             bpp = This->bytesPerPixel;
1020         }
1021         break;
1022
1023         case WINED3DFMT_X8R8G8B8:
1024         {
1025             /* make sure the X byte is set to alpha on, since it
1026                could be any random value. This fixes the intro movie in Pirates! */
1027             int size;
1028             unsigned int *data;
1029             data = (unsigned int *)This->resource.allocatedMemory;
1030             size = (This->lockedRect.bottom - This->lockedRect.top) * (This->lockedRect.right - This->lockedRect.left);
1031             while(size > 0) {
1032                 *data |= 0xFF000000;
1033                 data++;
1034                 size--;
1035             }
1036         }
1037         /* Fall through */
1038
1039         case WINED3DFMT_A8R8G8B8:
1040         {
1041             glPixelStorei(GL_PACK_SWAP_BYTES, TRUE);
1042             vcheckGLcall("glPixelStorei");
1043             storechanged = TRUE;
1044             type = This->glDescription.glType;
1045             fmt = This->glDescription.glFormat;
1046             mem = This->resource.allocatedMemory;
1047             bpp = This->bytesPerPixel;
1048         }
1049         break;
1050
1051         case WINED3DFMT_A2R10G10B10:
1052         {
1053             glPixelStorei(GL_PACK_SWAP_BYTES, TRUE);
1054             vcheckGLcall("glPixelStorei");
1055             storechanged = TRUE;
1056             type = This->glDescription.glType;
1057             fmt = This->glDescription.glFormat;
1058             mem = This->resource.allocatedMemory;
1059             bpp = This->bytesPerPixel;
1060         }
1061         break;
1062
1063         case WINED3DFMT_P8:
1064         {
1065             int height = This->glRect.bottom - This->glRect.top;
1066             type = GL_UNSIGNED_BYTE;
1067             fmt = GL_RGBA;
1068
1069             mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * sizeof(DWORD));
1070             if(!mem) {
1071                 ERR("Out of memory\n");
1072                 return;
1073             }
1074             memory_allocated = TRUE;
1075             d3dfmt_convert_surface(This->resource.allocatedMemory,
1076                                    mem,
1077                                    pitch,
1078                                    pitch,
1079                                    height,
1080                                    pitch * 4,
1081                                    CONVERT_PALETTED,
1082                                    This);
1083             bpp = This->bytesPerPixel * 4;
1084             pitch *= 4;
1085         }
1086         break;
1087
1088         default:
1089             FIXME("Unsupported Format %u in locking func\n", This->resource.format);
1090
1091             /* Give it a try */
1092             type = This->glDescription.glType;
1093             fmt = This->glDescription.glFormat;
1094             mem = This->resource.allocatedMemory;
1095             bpp = This->bytesPerPixel;
1096     }
1097
1098     if(This->Flags & SFLAG_PBO) {
1099         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1100         checkGLcall("glBindBufferARB");
1101     }
1102
1103     glDrawPixels(This->lockedRect.right - This->lockedRect.left,
1104                  (This->lockedRect.bottom - This->lockedRect.top)-1,
1105                  fmt, type,
1106                  mem + bpp * This->lockedRect.left + pitch * This->lockedRect.top);
1107     checkGLcall("glDrawPixels");
1108
1109     if(This->Flags & SFLAG_PBO) {
1110         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1111         checkGLcall("glBindBufferARB");
1112     }
1113
1114     glPixelZoom(1.0,1.0);
1115     vcheckGLcall("glPixelZoom");
1116
1117     glRasterPos3iv(&prev_rasterpos[0]);
1118     vcheckGLcall("glRasterPos3iv");
1119
1120     /* Reset to previous pack row length */
1121     glPixelStorei(GL_UNPACK_ROW_LENGTH, skipBytes);
1122     vcheckGLcall("glPixelStorei GL_UNPACK_ROW_LENGTH");
1123     if(storechanged) {
1124         glPixelStorei(GL_PACK_SWAP_BYTES, prev_store);
1125         vcheckGLcall("glPixelStorei GL_PACK_SWAP_BYTES");
1126     }
1127
1128     /* Blitting environment requires that 2D texturing is enabled. It was turned off before,
1129      * turn it on again
1130      */
1131     glEnable(GL_TEXTURE_2D);
1132     checkGLcall("glEnable(GL_TEXTURE_2D)");
1133
1134     if(memory_allocated) HeapFree(GetProcessHeap(), 0, mem);
1135     return;
1136 }
1137
1138 static void flush_to_framebuffer_texture(IWineD3DSurfaceImpl *This) {
1139     float glTexCoord[4];
1140
1141     glTexCoord[0] = (float) This->lockedRect.left   / (float) This->pow2Width; /* left */
1142     glTexCoord[1] = (float) This->lockedRect.right  / (float) This->pow2Width; /* right */
1143     glTexCoord[2] = (float) This->lockedRect.top    / (float) This->pow2Height; /* top */
1144     glTexCoord[3] = (float) This->lockedRect.bottom / (float) This->pow2Height; /* bottom */
1145
1146     IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
1147
1148     ENTER_GL();
1149
1150     glBindTexture(GL_TEXTURE_2D, This->glDescription.textureName);
1151     checkGLcall("glEnable glBindTexture");
1152
1153     /* No filtering for blts */
1154     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1155     checkGLcall("glTexParameteri");
1156     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1157     checkGLcall("glTexParameteri");
1158
1159     /* Start drawing a quad */
1160     glBegin(GL_QUADS);
1161
1162     glColor3d(1.0f, 1.0f, 1.0f);
1163     glTexCoord2f(glTexCoord[0], glTexCoord[2]);
1164     glVertex3f(This->lockedRect.left, This->lockedRect.top, 0.0);
1165
1166     glTexCoord2f(glTexCoord[0], glTexCoord[3]);
1167     glVertex3f(This->lockedRect.left, This->lockedRect.bottom, 0.0);
1168
1169     glTexCoord2f(glTexCoord[1], glTexCoord[3]);
1170     glVertex3d(This->lockedRect.right, This->lockedRect.bottom, 0.0);
1171
1172     glTexCoord2f(glTexCoord[1], glTexCoord[2]);
1173     glVertex3f(This->lockedRect.right, This->lockedRect.top, 0.0);
1174
1175     glEnd();
1176     checkGLcall("glEnd");
1177
1178     /* Unbind the texture */
1179     glBindTexture(GL_TEXTURE_2D, 0);
1180     checkGLcall("glEnable glBindTexture");
1181
1182     LEAVE_GL();
1183 }
1184
1185 static HRESULT WINAPI IWineD3DSurfaceImpl_UnlockRect(IWineD3DSurface *iface) {
1186     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1187     IWineD3DDeviceImpl  *myDevice = This->resource.wineD3DDevice;
1188     IWineD3DSwapChainImpl *swapchain = NULL;
1189
1190     if (!(This->Flags & SFLAG_LOCKED)) {
1191         WARN("trying to Unlock an unlocked surf@%p\n", This);
1192         return WINED3DERR_INVALIDCALL;
1193     }
1194
1195     if (This->Flags & SFLAG_PBO) {
1196         TRACE("Freeing PBO memory\n");
1197         ActivateContext(myDevice, myDevice->lastActiveRenderTarget, CTXUSAGE_RESOURCELOAD);
1198         ENTER_GL();
1199         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1200         GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1201         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1202         checkGLcall("glUnmapBufferARB");
1203         LEAVE_GL();
1204         This->resource.allocatedMemory = NULL;
1205     }
1206
1207     TRACE("(%p) : dirtyfied(%d)\n", This, This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
1208
1209     if (This->Flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE)) {
1210         TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This);
1211         goto unlock_end;
1212     }
1213
1214     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapchain);
1215     if(swapchain || (myDevice->render_targets && iface == myDevice->render_targets[0])) {
1216         if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1217             static BOOL warned = FALSE;
1218             if(!warned) {
1219                 ERR("The application tries to write to the render target, but render target locking is disabled\n");
1220                 warned = TRUE;
1221             }
1222             if(swapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
1223             goto unlock_end;
1224         }
1225
1226         /* Activate the correct context for the render target */
1227         ActivateContext(myDevice, iface, CTXUSAGE_BLIT);
1228         ENTER_GL();
1229
1230         if(!swapchain) {
1231             /* Primary offscreen render target */
1232             TRACE("Offscreen render target\n");
1233             glDrawBuffer(myDevice->offscreenBuffer);
1234             checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1235         } else {
1236             GLenum buffer = surface_get_gl_buffer(iface, (IWineD3DSwapChain *)swapchain);
1237             TRACE("Unlocking %#x buffer\n", buffer);
1238             glDrawBuffer(buffer);
1239             checkGLcall("glDrawBuffer");
1240
1241             IWineD3DSwapChain_Release((IWineD3DSwapChain *)swapchain);
1242         }
1243
1244         switch(wined3d_settings.rendertargetlock_mode) {
1245             case RTL_AUTO:
1246             case RTL_READDRAW:
1247             case RTL_TEXDRAW:
1248                 flush_to_framebuffer_drawpixels(This);
1249                 break;
1250
1251             case RTL_READTEX:
1252             case RTL_TEXTEX:
1253                 flush_to_framebuffer_texture(This);
1254                 break;
1255         }
1256         if(!swapchain) {
1257             glDrawBuffer(myDevice->offscreenBuffer);
1258             checkGLcall("glDrawBuffer(myDevice->offscreenBuffer)");
1259         } else if(swapchain->backBuffer) {
1260             glDrawBuffer(GL_BACK);
1261             checkGLcall("glDrawBuffer(GL_BACK)");
1262         } else {
1263             glDrawBuffer(GL_FRONT);
1264             checkGLcall("glDrawBuffer(GL_FRONT)");
1265         }
1266         LEAVE_GL();
1267
1268         This->dirtyRect.left   = This->currentDesc.Width;
1269         This->dirtyRect.top    = This->currentDesc.Height;
1270         This->dirtyRect.right  = 0;
1271         This->dirtyRect.bottom = 0;
1272         This->Flags |= SFLAG_INDRAWABLE;
1273     } else if(iface == myDevice->stencilBufferTarget) {
1274         FIXME("Depth Stencil buffer locking is not implemented\n");
1275     } else {
1276         /* The rest should be a normal texture */
1277         IWineD3DBaseTextureImpl *impl;
1278         /* Check if the texture is bound, if yes dirtify the sampler to force a re-upload of the texture
1279          * Can't load the texture here because PreLoad may destroy and recreate the gl texture, so sampler
1280          * states need resetting
1281          */
1282         if(IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&impl) == WINED3D_OK) {
1283             if(impl->baseTexture.bindCount) {
1284                 IWineD3DDeviceImpl_MarkStateDirty(myDevice, STATE_SAMPLER(impl->baseTexture.sampler));
1285             }
1286             IWineD3DBaseTexture_Release((IWineD3DBaseTexture *) impl);
1287         }
1288     }
1289
1290     unlock_end:
1291     This->Flags &= ~SFLAG_LOCKED;
1292     memset(&This->lockedRect, 0, sizeof(RECT));
1293     return WINED3D_OK;
1294 }
1295
1296 HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC) {
1297     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1298     WINED3DLOCKED_RECT lock;
1299     HRESULT hr;
1300     RGBQUAD col[256];
1301
1302     TRACE("(%p)->(%p)\n",This,pHDC);
1303
1304     if(This->Flags & SFLAG_USERPTR) {
1305         ERR("Not supported on surfaces with an application-provided surfaces\n");
1306         return WINEDDERR_NODC;
1307     }
1308
1309     /* Give more detailed info for ddraw */
1310     if (This->Flags & SFLAG_DCINUSE)
1311         return WINEDDERR_DCALREADYCREATED;
1312
1313     /* Can't GetDC if the surface is locked */
1314     if (This->Flags & SFLAG_LOCKED)
1315         return WINED3DERR_INVALIDCALL;
1316
1317     memset(&lock, 0, sizeof(lock)); /* To be sure */
1318
1319     /* Create a DIB section if there isn't a hdc yet */
1320     if(!This->hDC) {
1321         IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
1322         if(This->Flags & SFLAG_CLIENT) {
1323             IWineD3DSurface_PreLoad(iface);
1324         }
1325
1326         /* Use the dib section from now on if we are not using a PBO */
1327         if(!(This->Flags & SFLAG_PBO))
1328             This->resource.allocatedMemory = This->dib.bitmap_data;
1329     }
1330
1331     /* Lock the surface */
1332     hr = IWineD3DSurface_LockRect(iface,
1333                                   &lock,
1334                                   NULL,
1335                                   0);
1336
1337     if(This->Flags & SFLAG_PBO) {
1338         /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1339         memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
1340     }
1341
1342     if(FAILED(hr)) {
1343         ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
1344         /* keep the dib section */
1345         return hr;
1346     }
1347
1348     if(This->resource.format == WINED3DFMT_P8 ||
1349         This->resource.format == WINED3DFMT_A8P8) {
1350         unsigned int n;
1351         if(This->palette) {
1352             PALETTEENTRY ent[256];
1353
1354             GetPaletteEntries(This->palette->hpal, 0, 256, ent);
1355             for (n=0; n<256; n++) {
1356                 col[n].rgbRed   = ent[n].peRed;
1357                 col[n].rgbGreen = ent[n].peGreen;
1358                 col[n].rgbBlue  = ent[n].peBlue;
1359                 col[n].rgbReserved = 0;
1360             }
1361         } else {
1362             IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1363
1364             for (n=0; n<256; n++) {
1365                 col[n].rgbRed   = device->palettes[device->currentPalette][n].peRed;
1366                 col[n].rgbGreen = device->palettes[device->currentPalette][n].peGreen;
1367                 col[n].rgbBlue  = device->palettes[device->currentPalette][n].peBlue;
1368                 col[n].rgbReserved = 0;
1369             }
1370
1371         }
1372         SetDIBColorTable(This->hDC, 0, 256, col);
1373     }
1374
1375     *pHDC = This->hDC;
1376     TRACE("returning %p\n",*pHDC);
1377     This->Flags |= SFLAG_DCINUSE;
1378
1379     return WINED3D_OK;
1380 }
1381
1382 HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
1383     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1384
1385     TRACE("(%p)->(%p)\n",This,hDC);
1386
1387     if (!(This->Flags & SFLAG_DCINUSE))
1388         return WINED3DERR_INVALIDCALL;
1389
1390     if (This->hDC !=hDC) {
1391         WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
1392         return WINED3DERR_INVALIDCALL;
1393     }
1394
1395     if((This->Flags & SFLAG_PBO) && This->resource.allocatedMemory) {
1396         /* Copy the contents of the DIB over to the PBO */
1397         memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
1398     }
1399
1400     /* we locked first, so unlock now */
1401     IWineD3DSurface_UnlockRect(iface);
1402
1403     This->Flags &= ~SFLAG_DCINUSE;
1404
1405     return WINED3D_OK;
1406 }
1407
1408 /* ******************************************************
1409    IWineD3DSurface Internal (No mapping to directx api) parts follow
1410    ****************************************************** */
1411
1412 HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, GLenum *format, GLenum *internal, GLenum *type, CONVERT_TYPES *convert, int *target_bpp, BOOL srgb_mode) {
1413     BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
1414     const GlPixelFormatDesc *glDesc;
1415     getFormatDescEntry(This->resource.format, &GLINFO_LOCATION, &glDesc);
1416
1417     /* Default values: From the surface */
1418     *format = glDesc->glFormat;
1419     *internal = srgb_mode?glDesc->glGammaInternal:glDesc->glInternal;
1420     *type = glDesc->glType;
1421     *convert = NO_CONVERSION;
1422     *target_bpp = This->bytesPerPixel;
1423
1424     /* Ok, now look if we have to do any conversion */
1425     switch(This->resource.format) {
1426         case WINED3DFMT_P8:
1427             /* ****************
1428                 Paletted Texture
1429                 **************** */
1430             /* Use conversion when the paletted texture extension is not available, or when it is available make sure it is used
1431              * for texturing as it won't work for calls like glDraw-/glReadPixels and further also use conversion in case of color keying.
1432              */
1433             if(!GL_SUPPORT(EXT_PALETTED_TEXTURE) || colorkey_active || (!use_texturing && GL_SUPPORT(EXT_PALETTED_TEXTURE)) ) {
1434                 *format = GL_RGBA;
1435                 *internal = GL_RGBA;
1436                 *type = GL_UNSIGNED_BYTE;
1437                 *target_bpp = 4;
1438                 if(colorkey_active) {
1439                     *convert = CONVERT_PALETTED_CK;
1440                 } else {
1441                     *convert = CONVERT_PALETTED;
1442                 }
1443             }
1444
1445             break;
1446
1447         case WINED3DFMT_R3G3B2:
1448             /* **********************
1449                 GL_UNSIGNED_BYTE_3_3_2
1450                 ********************** */
1451             if (colorkey_active) {
1452                 /* This texture format will never be used.. So do not care about color keying
1453                     up until the point in time it will be needed :-) */
1454                 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1455             }
1456             break;
1457
1458         case WINED3DFMT_R5G6B5:
1459             if (colorkey_active) {
1460                 *convert = CONVERT_CK_565;
1461                 *format = GL_RGBA;
1462                 *internal = GL_RGBA;
1463                 *type = GL_UNSIGNED_SHORT_5_5_5_1;
1464             }
1465             break;
1466
1467         case WINED3DFMT_X1R5G5B5:
1468             if (colorkey_active) {
1469                 *convert = CONVERT_CK_5551;
1470                 *format = GL_BGRA;
1471                 *internal = GL_RGBA;
1472                 *type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1473             }
1474             break;
1475
1476         case WINED3DFMT_R8G8B8:
1477             if (colorkey_active) {
1478                 *convert = CONVERT_CK_RGB24;
1479                 *format = GL_RGBA;
1480                 *internal = GL_RGBA;
1481                 *type = GL_UNSIGNED_INT_8_8_8_8;
1482                 *target_bpp = 4;
1483             }
1484             break;
1485
1486         case WINED3DFMT_X8R8G8B8:
1487             if (colorkey_active) {
1488                 *convert = CONVERT_RGB32_888;
1489                 *format = GL_RGBA;
1490                 *internal = GL_RGBA;
1491                 *type = GL_UNSIGNED_INT_8_8_8_8;
1492             }
1493             break;
1494
1495         case WINED3DFMT_V8U8:
1496             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1497             else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
1498                 *format = GL_DUDV_ATI;
1499                 *internal = GL_DU8DV8_ATI;
1500                 *type = GL_BYTE;
1501                 /* No conversion - Just change the gl type */
1502                 break;
1503             }
1504             *convert = CONVERT_V8U8;
1505             *format = GL_BGR;
1506             *internal = GL_RGB8;
1507             *type = GL_UNSIGNED_BYTE;
1508             *target_bpp = 3;
1509             break;
1510
1511         case WINED3DFMT_L6V5U5:
1512             *convert = CONVERT_L6V5U5;
1513             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1514                 *target_bpp = 3;
1515                 /* Use format and types from table */
1516             } else {
1517                 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1518                 *target_bpp = 2;
1519                 *format = GL_RGB;
1520                 *internal = GL_RGB5;
1521                 *type = GL_UNSIGNED_SHORT_5_6_5;
1522             }
1523             break;
1524
1525         case WINED3DFMT_X8L8V8U8:
1526             *convert = CONVERT_X8L8V8U8;
1527             *target_bpp = 4;
1528             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1529                 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1530                  * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1531                  * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1532                  * the needed type and format parameter, so the internal format contains a
1533                  * 4th component, which is returned as alpha
1534                  */
1535             } else {
1536                 /* Not supported by GL_ATI_envmap_bumpmap */
1537                 *format = GL_BGRA;
1538                 *internal = GL_RGBA8;
1539                 *type = GL_UNSIGNED_BYTE;
1540             }
1541             break;
1542
1543         case WINED3DFMT_Q8W8V8U8:
1544             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1545             *convert = CONVERT_Q8W8V8U8;
1546             *format = GL_BGRA;
1547             *internal = GL_RGBA8;
1548             *type = GL_UNSIGNED_BYTE;
1549             *target_bpp = 4;
1550             /* Not supported by GL_ATI_envmap_bumpmap */
1551             break;
1552
1553         case WINED3DFMT_V16U16:
1554             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1555             *convert = CONVERT_V16U16;
1556             *format = GL_BGR;
1557             *internal = GL_RGB16;
1558             *type = GL_SHORT;
1559             *target_bpp = 6;
1560             /* What should I do here about GL_ATI_envmap_bumpmap?
1561              * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1562              */
1563             break;
1564
1565         case WINED3DFMT_A4L4:
1566             /* A4L4 exists as an internal gl format, but for some reason there is not
1567              * format+type combination to load it. Thus convert it to A8L8, then load it
1568              * with A4L4 internal, but A8L8 format+type
1569              */
1570             *convert = CONVERT_A4L4;
1571             *format = GL_LUMINANCE_ALPHA;
1572             *internal = GL_LUMINANCE4_ALPHA4;
1573             *type = GL_UNSIGNED_BYTE;
1574             *target_bpp = 2;
1575             break;
1576
1577         case WINED3DFMT_R32F:
1578             /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1579              * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1580              * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1581              * 1.0 instead.
1582              *
1583              * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1584              */
1585             *convert = CONVERT_R32F;
1586             *format = GL_RGB;
1587             *internal = GL_RGB32F_ARB;
1588             *type = GL_FLOAT;
1589             *target_bpp = 12;
1590             break;
1591
1592         case WINED3DFMT_R16F:
1593             /* Similar to R32F */
1594             *convert = CONVERT_R16F;
1595             *format = GL_RGB;
1596             *internal = GL_RGB16F_ARB;
1597             *type = GL_HALF_FLOAT_ARB;
1598             *target_bpp = 6;
1599             break;
1600
1601         default:
1602             break;
1603     }
1604
1605     return WINED3D_OK;
1606 }
1607
1608 HRESULT d3dfmt_convert_surface(BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This) {
1609     BYTE *source, *dest;
1610     TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
1611
1612     switch (convert) {
1613         case NO_CONVERSION:
1614         {
1615             memcpy(dst, src, pitch * height);
1616             break;
1617         }
1618         case CONVERT_PALETTED:
1619         case CONVERT_PALETTED_CK:
1620         {
1621             IWineD3DPaletteImpl* pal = This->palette;
1622             BYTE table[256][4];
1623             unsigned int i;
1624             unsigned int x, y;
1625
1626             if( pal == NULL) {
1627                 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1628             }
1629
1630             if (pal == NULL) {
1631                 /* Still no palette? Use the device's palette */
1632                 /* Get the surface's palette */
1633                 for (i = 0; i < 256; i++) {
1634                     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1635
1636                     table[i][0] = device->palettes[device->currentPalette][i].peRed;
1637                     table[i][1] = device->palettes[device->currentPalette][i].peGreen;
1638                     table[i][2] = device->palettes[device->currentPalette][i].peBlue;
1639                     if ((convert == CONVERT_PALETTED_CK) &&
1640                         (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1641                         (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1642                         /* We should maybe here put a more 'neutral' color than the standard bright purple
1643                           one often used by application to prevent the nice purple borders when bi-linear
1644                           filtering is on */
1645                         table[i][3] = 0x00;
1646                     } else {
1647                         table[i][3] = 0xFF;
1648                     }
1649                 }
1650             } else {
1651                 TRACE("Using surface palette %p\n", pal);
1652                 /* Get the surface's palette */
1653                 for (i = 0; i < 256; i++) {
1654                     table[i][0] = pal->palents[i].peRed;
1655                     table[i][1] = pal->palents[i].peGreen;
1656                     table[i][2] = pal->palents[i].peBlue;
1657                     if ((convert == CONVERT_PALETTED_CK) &&
1658                         (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1659                         (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1660                         /* We should maybe here put a more 'neutral' color than the standard bright purple
1661                           one often used by application to prevent the nice purple borders when bi-linear
1662                           filtering is on */
1663                         table[i][3] = 0x00;
1664                     } else if(pal->Flags & WINEDDPCAPS_ALPHA) {
1665                         table[i][3] = pal->palents[i].peFlags;
1666                     } else {
1667                         table[i][3] = 0xFF;
1668                     }
1669                 }
1670             }
1671
1672             for (y = 0; y < height; y++)
1673             {
1674                 source = src + pitch * y;
1675                 dest = dst + outpitch * y;
1676                 /* This is an 1 bpp format, using the width here is fine */
1677                 for (x = 0; x < width; x++) {
1678                     BYTE color = *source++;
1679                     *dest++ = table[color][0];
1680                     *dest++ = table[color][1];
1681                     *dest++ = table[color][2];
1682                     *dest++ = table[color][3];
1683                 }
1684             }
1685         }
1686         break;
1687
1688         case CONVERT_CK_565:
1689         {
1690             /* Converting the 565 format in 5551 packed to emulate color-keying.
1691
1692               Note : in all these conversion, it would be best to average the averaging
1693                       pixels to get the color of the pixel that will be color-keyed to
1694                       prevent 'color bleeding'. This will be done later on if ever it is
1695                       too visible.
1696
1697               Note2: Nvidia documents say that their driver does not support alpha + color keying
1698                      on the same surface and disables color keying in such a case
1699             */
1700             unsigned int x, y;
1701             WORD *Source;
1702             WORD *Dest;
1703
1704             TRACE("Color keyed 565\n");
1705
1706             for (y = 0; y < height; y++) {
1707                 Source = (WORD *) (src + y * pitch);
1708                 Dest = (WORD *) (dst + y * outpitch);
1709                 for (x = 0; x < width; x++ ) {
1710                     WORD color = *Source++;
1711                     *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
1712                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1713                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1714                         *Dest |= 0x0001;
1715                     }
1716                     Dest++;
1717                 }
1718             }
1719         }
1720         break;
1721
1722         case CONVERT_CK_5551:
1723         {
1724             /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1725             unsigned int x, y;
1726             WORD *Source;
1727             WORD *Dest;
1728             TRACE("Color keyed 5551\n");
1729             for (y = 0; y < height; y++) {
1730                 Source = (WORD *) (src + y * pitch);
1731                 Dest = (WORD *) (dst + y * outpitch);
1732                 for (x = 0; x < width; x++ ) {
1733                     WORD color = *Source++;
1734                     *Dest = color;
1735                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1736                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1737                         *Dest |= (1 << 15);
1738                     }
1739                     else {
1740                         *Dest &= ~(1 << 15);
1741                     }
1742                     Dest++;
1743                 }
1744             }
1745         }
1746         break;
1747
1748         case CONVERT_V8U8:
1749         {
1750             unsigned int x, y;
1751             short *Source;
1752             unsigned char *Dest;
1753             for(y = 0; y < height; y++) {
1754                 Source = (short *) (src + y * pitch);
1755                 Dest = (unsigned char *) (dst + y * outpitch);
1756                 for (x = 0; x < width; x++ ) {
1757                     long color = (*Source++);
1758                     /* B */ Dest[0] = 0xff;
1759                     /* G */ Dest[1] = (color >> 8) + 128; /* V */
1760                     /* R */ Dest[2] = (color) + 128;      /* U */
1761                     Dest += 3;
1762                 }
1763             }
1764             break;
1765         }
1766
1767         case CONVERT_Q8W8V8U8:
1768         {
1769             unsigned int x, y;
1770             DWORD *Source;
1771             unsigned char *Dest;
1772             for(y = 0; y < height; y++) {
1773                 Source = (DWORD *) (src + y * pitch);
1774                 Dest = (unsigned char *) (dst + y * outpitch);
1775                 for (x = 0; x < width; x++ ) {
1776                     long color = (*Source++);
1777                     /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
1778                     /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
1779                     /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
1780                     /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
1781                     Dest += 4;
1782                 }
1783             }
1784             break;
1785         }
1786
1787         case CONVERT_L6V5U5:
1788         {
1789             unsigned int x, y;
1790             WORD *Source;
1791             unsigned char *Dest;
1792
1793             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1794                 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1795                  * fixed function and shaders without further conversion once the surface is
1796                  * loaded
1797                  */
1798                 for(y = 0; y < height; y++) {
1799                     Source = (WORD *) (src + y * pitch);
1800                     Dest = (unsigned char *) (dst + y * outpitch);
1801                     for (x = 0; x < width; x++ ) {
1802                         short color = (*Source++);
1803                         unsigned char l = ((color >> 10) & 0xfc);
1804                                   char v = ((color >>  5) & 0x3e);
1805                                   char u = ((color      ) & 0x1f);
1806
1807                         /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1808                          * and doubles the positive range. Thus shift left only once, gl does the 2nd
1809                          * shift. GL reads a signed value and converts it into an unsigned value.
1810                          */
1811                         /* M */ Dest[2] = l << 1;
1812
1813                         /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1814                          * from 5 bit values to 8 bit values.
1815                          */
1816                         /* V */ Dest[1] = v << 3;
1817                         /* U */ Dest[0] = u << 3;
1818                         Dest += 3;
1819                     }
1820                 }
1821             } else {
1822                 FIXME("Add D3DFMT_L6V5U5 emulation using standard unsigned RGB and shaders\n");
1823             }
1824             break;
1825         }
1826
1827         case CONVERT_X8L8V8U8:
1828         {
1829             unsigned int x, y;
1830             DWORD *Source;
1831             unsigned char *Dest;
1832
1833             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1834                 /* This implementation works with the fixed function pipeline and shaders
1835                  * without further modification after converting the surface.
1836                  */
1837                 for(y = 0; y < height; y++) {
1838                     Source = (DWORD *) (src + y * pitch);
1839                     Dest = (unsigned char *) (dst + y * outpitch);
1840                     for (x = 0; x < width; x++ ) {
1841                         long color = (*Source++);
1842                         /* L */ Dest[2] = ((color >> 16) & 0xff);   /* L */
1843                         /* V */ Dest[1] = ((color >> 8 ) & 0xff);   /* V */
1844                         /* U */ Dest[0] = (color         & 0xff);   /* U */
1845                         /* I */ Dest[3] = 255;                      /* X */
1846                         Dest += 4;
1847                     }
1848                 }
1849             } else {
1850                 /* Doesn't work correctly with the fixed function pipeline, but can work in
1851                  * shaders if the shader is adjusted. (There's no use for this format in gl's
1852                  * standard fixed function pipeline anyway).
1853                  */
1854                 FIXME("Implement CONVERT_X8L8V8U8 with standard unsigned GL_RGB\n");
1855             }
1856             break;
1857         }
1858
1859         case CONVERT_A4L4:
1860         {
1861             unsigned int x, y;
1862             unsigned char *Source;
1863             unsigned char *Dest;
1864             for(y = 0; y < height; y++) {
1865                 Source = (unsigned char *) (src + y * pitch);
1866                 Dest = (unsigned char *) (dst + y * outpitch);
1867                 for (x = 0; x < width; x++ ) {
1868                     unsigned char color = (*Source++);
1869                     /* A */ Dest[1] = (color & 0xf0) << 0;
1870                     /* L */ Dest[0] = (color & 0x0f) << 4;
1871                     Dest += 2;
1872                 }
1873             }
1874             break;
1875         }
1876
1877         case CONVERT_R32F:
1878         {
1879             unsigned int x, y;
1880             float *Source;
1881             float *Dest;
1882             for(y = 0; y < height; y++) {
1883                 Source = (float *) (src + y * pitch);
1884                 Dest = (float *) (dst + y * outpitch);
1885                 for (x = 0; x < width; x++ ) {
1886                     float color = (*Source++);
1887                     Dest[0] = color;
1888                     Dest[1] = 1.0;
1889                     Dest[2] = 1.0;
1890                     Dest += 3;
1891                 }
1892             }
1893             break;
1894         }
1895
1896         case CONVERT_R16F:
1897         {
1898             unsigned int x, y;
1899             WORD *Source;
1900             WORD *Dest;
1901             WORD one = 0x3c00;
1902             for(y = 0; y < height; y++) {
1903                 Source = (WORD *) (src + y * pitch);
1904                 Dest = (WORD *) (dst + y * outpitch);
1905                 for (x = 0; x < width; x++ ) {
1906                     WORD color = (*Source++);
1907                     Dest[0] = color;
1908                     Dest[1] = one;
1909                     Dest[2] = one;
1910                     Dest += 3;
1911                 }
1912             }
1913             break;
1914         }
1915         default:
1916             ERR("Unsupported conversation type %d\n", convert);
1917     }
1918     return WINED3D_OK;
1919 }
1920
1921 /* This function is used in case of 8bit paletted textures to upload the palette.
1922    For now it only supports GL_EXT_paletted_texture extension but support for other
1923    extensions like ARB_fragment_program and ATI_fragment_shaders will be added as well.
1924 */
1925 static void d3dfmt_p8_upload_palette(IWineD3DSurface *iface, CONVERT_TYPES convert) {
1926     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1927     IWineD3DPaletteImpl* pal = This->palette;
1928     BYTE table[256][4];
1929     int i;
1930
1931     if (pal == NULL) {
1932         /* Still no palette? Use the device's palette */
1933         /* Get the surface's palette */
1934         for (i = 0; i < 256; i++) {
1935             IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1936
1937             table[i][0] = device->palettes[device->currentPalette][i].peRed;
1938             table[i][1] = device->palettes[device->currentPalette][i].peGreen;
1939             table[i][2] = device->palettes[device->currentPalette][i].peBlue;
1940             if ((convert == CONVERT_PALETTED_CK) &&
1941                 (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1942                 (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1943                 /* We should maybe here put a more 'neutral' color than the standard bright purple
1944                    one often used by application to prevent the nice purple borders when bi-linear
1945                    filtering is on */
1946                 table[i][3] = 0x00;
1947             } else {
1948                 table[i][3] = 0xFF;
1949             }
1950         }
1951     } else {
1952         TRACE("Using surface palette %p\n", pal);
1953         /* Get the surface's palette */
1954         for (i = 0; i < 256; i++) {
1955             table[i][0] = pal->palents[i].peRed;
1956             table[i][1] = pal->palents[i].peGreen;
1957             table[i][2] = pal->palents[i].peBlue;
1958             if ((convert == CONVERT_PALETTED_CK) &&
1959                 (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1960                 (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1961                 /* We should maybe here put a more 'neutral' color than the standard bright purple
1962                    one often used by application to prevent the nice purple borders when bi-linear
1963                    filtering is on */
1964                 table[i][3] = 0x00;
1965             } else if(pal->Flags & WINEDDPCAPS_ALPHA) {
1966                 table[i][3] = pal->palents[i].peFlags;
1967             } else {
1968                 table[i][3] = 0xFF;
1969             }
1970         }
1971     }
1972     GL_EXTCALL(glColorTableEXT(GL_TEXTURE_2D,GL_RGBA,256,GL_RGBA,GL_UNSIGNED_BYTE, table));
1973 }
1974
1975 static BOOL palette9_changed(IWineD3DSurfaceImpl *This) {
1976     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1977
1978     if(This->palette || (This->resource.format != WINED3DFMT_P8 && This->resource.format != WINED3DFMT_A8P8)) {
1979         /* If a ddraw-style palette is attached assume no d3d9 palette change.
1980          * Also the palette isn't interesting if the surface format isn't P8 or A8P8
1981          */
1982         return FALSE;
1983     }
1984
1985     if(This->palette9) {
1986         if(memcmp(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256) == 0) {
1987             return FALSE;
1988         }
1989     } else {
1990         This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
1991     }
1992     memcpy(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
1993     return TRUE;
1994 }
1995
1996 static inline void clear_unused_channels(IWineD3DSurfaceImpl *This) {
1997     GLboolean oldwrite[4];
1998
1999     /* Some formats have only some color channels, and the others are 1.0.
2000      * since our rendering renders to all channels, and those pixel formats
2001      * are emulated by using a full texture with the other channels set to 1.0
2002      * manually, clear the unused channels.
2003      *
2004      * This could be done with hacking colorwriteenable to mask the colors,
2005      * but before drawing the buffer would have to be cleared too, so there's
2006      * no gain in that
2007      */
2008     switch(This->resource.format) {
2009         case WINED3DFMT_R16F:
2010         case WINED3DFMT_R32F:
2011             TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2012             /* Do not activate a context, the correct drawable is active already
2013              * though just the read buffer is set, make sure to have the correct draw
2014              * buffer too
2015              */
2016             glDrawBuffer(This->resource.wineD3DDevice->offscreenBuffer);
2017             glDisable(GL_SCISSOR_TEST);
2018             glGetBooleanv(GL_COLOR_WRITEMASK, oldwrite);
2019             glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
2020             glClearColor(0.0, 1.0, 1.0, 1.0);
2021             glClear(GL_COLOR_BUFFER_BIT);
2022             glColorMask(oldwrite[0], oldwrite[1], oldwrite[2], oldwrite[3]);
2023             if(!This->resource.wineD3DDevice->render_offscreen) glDrawBuffer(GL_BACK);
2024             checkGLcall("Unused channel clear\n");
2025             break;
2026
2027         default: break;
2028     }
2029 }
2030
2031 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) {
2032     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2033     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2034     GLenum format, internal, type;
2035     CONVERT_TYPES convert;
2036     int bpp;
2037     int width, pitch, outpitch;
2038     BYTE *mem;
2039
2040     if (!(This->Flags & SFLAG_INTEXTURE)) {
2041         TRACE("Reloading because surface is dirty\n");
2042     } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2043               ((This->Flags & SFLAG_GLCKEY) && (!(This->CKeyFlags & WINEDDSD_CKSRCBLT))) ||
2044               /* Reload: vice versa  OR */
2045               ((!(This->Flags & SFLAG_GLCKEY)) && (This->CKeyFlags & WINEDDSD_CKSRCBLT)) ||
2046               /* Also reload: Color key is active AND the color key has changed */
2047               ((This->CKeyFlags & WINEDDSD_CKSRCBLT) && (
2048                 (This->glCKey.dwColorSpaceLowValue != This->SrcBltCKey.dwColorSpaceLowValue) ||
2049                 (This->glCKey.dwColorSpaceHighValue != This->SrcBltCKey.dwColorSpaceHighValue)))) {
2050         TRACE("Reloading because of color keying\n");
2051     } else if(palette9_changed(This)) {
2052         TRACE("Reloading surface because the d3d8/9 palette was changed\n");
2053     } else {
2054         TRACE("surface is already in texture\n");
2055         return WINED3D_OK;
2056     }
2057
2058     This->Flags |= SFLAG_INTEXTURE;
2059
2060     /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2061     *  These resources are not bound by device size or format restrictions. Because of this,
2062     *  these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2063     *  However, these resources can always be created, locked, and copied.
2064     */
2065     if (This->resource.pool == WINED3DPOOL_SCRATCH )
2066     {
2067         FIXME("(%p) Operation not supported for scratch textures\n",This);
2068         return WINED3DERR_INVALIDCALL;
2069     }
2070
2071     d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb_mode);
2072
2073     if (This->Flags & SFLAG_INDRAWABLE) {
2074         if (This->resource.format == WINED3DFMT_P8 || This->resource.format == WINED3DFMT_A8P8 ||
2075                  This->resource.format == WINED3DFMT_DXT1 || This->resource.format == WINED3DFMT_DXT2 ||
2076                  This->resource.format == WINED3DFMT_DXT3 || This->resource.format == WINED3DFMT_DXT4 ||
2077                  This->resource.format == WINED3DFMT_DXT5)
2078             FIXME("Format %d not supported\n", This->resource.format);
2079         else {
2080             GLint prevRead;
2081
2082             ENTER_GL();
2083             glGetIntegerv(GL_READ_BUFFER, &prevRead);
2084             vcheckGLcall("glGetIntegerv");
2085             glReadBuffer(This->resource.wineD3DDevice->offscreenBuffer);
2086             vcheckGLcall("glReadBuffer");
2087
2088             if(!(This->Flags & SFLAG_ALLOCATED)) {
2089                 surface_allocate_surface(This, internal, This->pow2Width,
2090                                          This->pow2Height, format, type);
2091             }
2092
2093             clear_unused_channels(This);
2094
2095             glCopyTexSubImage2D(This->glDescription.target,
2096                                 This->glDescription.level,
2097                                 0, 0, 0, 0,
2098                                 This->currentDesc.Width,
2099                                 This->currentDesc.Height);
2100             checkGLcall("glCopyTexSubImage2D");
2101
2102             glReadBuffer(prevRead);
2103             vcheckGLcall("glReadBuffer");
2104
2105             LEAVE_GL();
2106
2107             TRACE("Updated target %d\n", This->glDescription.target);
2108         }
2109         return WINED3D_OK;
2110     } else
2111         /* The only place where LoadTexture() might get called when isInDraw=1
2112          * is ActivateContext where lastActiveRenderTarget is preloaded.
2113          */
2114         if(iface == device->lastActiveRenderTarget && device->isInDraw)
2115             ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
2116
2117     /* Otherwise: System memory copy must be most up to date */
2118
2119     if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
2120         This->Flags |= SFLAG_GLCKEY;
2121         This->glCKey = This->SrcBltCKey;
2122     }
2123     else This->Flags &= ~SFLAG_GLCKEY;
2124
2125     /* The width is in 'length' not in bytes */
2126     width = This->currentDesc.Width;
2127     pitch = IWineD3DSurface_GetPitch(iface);
2128
2129     if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
2130         int height = This->currentDesc.Height;
2131
2132         /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
2133         outpitch = width * bpp;
2134         outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
2135
2136         mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
2137         if(!mem) {
2138             ERR("Out of memory %d, %d!\n", outpitch, height);
2139             return WINED3DERR_OUTOFVIDEOMEMORY;
2140         }
2141         d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
2142
2143         This->Flags |= SFLAG_CONVERTED;
2144     } else if (This->resource.format == WINED3DFMT_P8 && GL_SUPPORT(EXT_PALETTED_TEXTURE)) {
2145         d3dfmt_p8_upload_palette(iface, convert);
2146         This->Flags &= ~SFLAG_CONVERTED;
2147         mem = This->resource.allocatedMemory;
2148     } else {
2149         This->Flags &= ~SFLAG_CONVERTED;
2150         mem = This->resource.allocatedMemory;
2151     }
2152
2153     /* Make sure the correct pitch is used */
2154     glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
2155
2156     if ((This->Flags & SFLAG_NONPOW2) && !(This->Flags & SFLAG_OVERSIZE)) {
2157         TRACE("non power of two support\n");
2158         if(!(This->Flags & SFLAG_ALLOCATED)) {
2159             surface_allocate_surface(This, internal, This->pow2Width, This->pow2Height, format, type);
2160         }
2161         if (mem || (This->Flags & SFLAG_PBO)) {
2162             surface_upload_data(This, internal, This->currentDesc.Width, This->currentDesc.Height, format, type, mem);
2163         }
2164     } else {
2165         /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
2166          * changed. So also keep track of memory changes. In this case the texture has to be reallocated
2167          */
2168         if(!(This->Flags & SFLAG_ALLOCATED)) {
2169             surface_allocate_surface(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type);
2170         }
2171         if (mem || (This->Flags & SFLAG_PBO)) {
2172             surface_upload_data(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type, mem);
2173         }
2174     }
2175
2176     /* Restore the default pitch */
2177     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2178
2179     /* Don't delete PBO memory */
2180     if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
2181         HeapFree(GetProcessHeap(), 0, mem);
2182
2183 #if 0
2184     {
2185         static unsigned int gen = 0;
2186         char buffer[4096];
2187         ++gen;
2188         if ((gen % 10) == 0) {
2189             snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
2190             IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
2191         }
2192         /*
2193          * debugging crash code
2194          if (gen == 250) {
2195          void** test = NULL;
2196          *test = 0;
2197          }
2198          */
2199     }
2200 #endif
2201
2202     if (!(This->Flags & SFLAG_DONOTFREE)) {
2203         HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
2204         This->resource.allocatedMemory = NULL;
2205         This->Flags &= ~SFLAG_INSYSMEM;
2206     }
2207
2208     return WINED3D_OK;
2209 }
2210
2211 #include <errno.h>
2212 #include <stdio.h>
2213 HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename) {
2214     FILE* f = NULL;
2215     UINT i, y;
2216     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2217     char *allocatedMemory;
2218     char *textureRow;
2219     IWineD3DSwapChain *swapChain = NULL;
2220     int width, height;
2221     GLuint tmpTexture = 0;
2222     DWORD color;
2223     /*FIXME:
2224     Textures may not be stored in ->allocatedgMemory and a GlTexture
2225     so we should lock the surface before saving a snapshot, or at least check that
2226     */
2227     /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2228     by calling GetTexImage and in compressed form by calling
2229     GetCompressedTexImageARB.  Queried compressed images can be saved and
2230     later reused by calling CompressedTexImage[123]DARB.  Pre-compressed
2231     texture images do not need to be processed by the GL and should
2232     significantly improve texture loading performance relative to uncompressed
2233     images. */
2234
2235 /* Setup the width and height to be the internal texture width and height. */
2236     width  = This->pow2Width;
2237     height = This->pow2Height;
2238 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2239     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapChain);
2240
2241     if (This->Flags & SFLAG_INDRAWABLE && !(This->Flags & SFLAG_INTEXTURE)) {
2242         /* if were not a real texture then read the back buffer into a real texture */
2243         /* we don't want to interfere with the back buffer so read the data into a temporary
2244          * texture and then save the data out of the temporary texture
2245          */
2246         GLint prevRead;
2247         ENTER_GL();
2248         TRACE("(%p) Reading render target into texture\n", This);
2249         glEnable(GL_TEXTURE_2D);
2250
2251         glGenTextures(1, &tmpTexture);
2252         glBindTexture(GL_TEXTURE_2D, tmpTexture);
2253
2254         glTexImage2D(GL_TEXTURE_2D,
2255                         0,
2256                         GL_RGBA,
2257                         width,
2258                         height,
2259                         0/*border*/,
2260                         GL_RGBA,
2261                         GL_UNSIGNED_INT_8_8_8_8_REV,
2262                         NULL);
2263
2264         glGetIntegerv(GL_READ_BUFFER, &prevRead);
2265         vcheckGLcall("glGetIntegerv");
2266         glReadBuffer(swapChain ? GL_BACK : This->resource.wineD3DDevice->offscreenBuffer);
2267         vcheckGLcall("glReadBuffer");
2268         glCopyTexImage2D(GL_TEXTURE_2D,
2269                             0,
2270                             GL_RGBA,
2271                             0,
2272                             0,
2273                             width,
2274                             height,
2275                             0);
2276
2277         checkGLcall("glCopyTexImage2D");
2278         glReadBuffer(prevRead);
2279         LEAVE_GL();
2280
2281     } else { /* bind the real texture, and make sure it up to date */
2282         IWineD3DSurface_PreLoad(iface);
2283     }
2284     allocatedMemory = HeapAlloc(GetProcessHeap(), 0, width  * height * 4);
2285     ENTER_GL();
2286     FIXME("Saving texture level %d width %d height %d\n", This->glDescription.level, width, height);
2287     glGetTexImage(GL_TEXTURE_2D,
2288                 This->glDescription.level,
2289                 GL_RGBA,
2290                 GL_UNSIGNED_INT_8_8_8_8_REV,
2291                 allocatedMemory);
2292     checkGLcall("glTexImage2D");
2293     if (tmpTexture) {
2294         glBindTexture(GL_TEXTURE_2D, 0);
2295         glDeleteTextures(1, &tmpTexture);
2296     }
2297     LEAVE_GL();
2298
2299     f = fopen(filename, "w+");
2300     if (NULL == f) {
2301         ERR("opening of %s failed with: %s\n", filename, strerror(errno));
2302         return WINED3DERR_INVALIDCALL;
2303     }
2304 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2305     TRACE("(%p) opened %s with format %s\n", This, filename, debug_d3dformat(This->resource.format));
2306 /* TGA header */
2307     fputc(0,f);
2308     fputc(0,f);
2309     fputc(2,f);
2310     fputc(0,f);
2311     fputc(0,f);
2312     fputc(0,f);
2313     fputc(0,f);
2314     fputc(0,f);
2315     fputc(0,f);
2316     fputc(0,f);
2317     fputc(0,f);
2318     fputc(0,f);
2319 /* short width*/
2320     fwrite(&width,2,1,f);
2321 /* short height */
2322     fwrite(&height,2,1,f);
2323 /* format rgba */
2324     fputc(0x20,f);
2325     fputc(0x28,f);
2326 /* raw data */
2327     /* if the data is upside down if we've fetched it from a back buffer, so it needs flipping again to make it the correct way up */
2328     if(swapChain)
2329         textureRow = allocatedMemory + (width * (height - 1) *4);
2330     else
2331         textureRow = allocatedMemory;
2332     for (y = 0 ; y < height; y++) {
2333         for (i = 0; i < width;  i++) {
2334             color = *((DWORD*)textureRow);
2335             fputc((color >> 16) & 0xFF, f); /* B */
2336             fputc((color >>  8) & 0xFF, f); /* G */
2337             fputc((color >>  0) & 0xFF, f); /* R */
2338             fputc((color >> 24) & 0xFF, f); /* A */
2339             textureRow += 4;
2340         }
2341         /* take two rows of the pointer to the texture memory */
2342         if(swapChain)
2343             (textureRow-= width << 3);
2344
2345     }
2346     TRACE("Closing file\n");
2347     fclose(f);
2348
2349     if(swapChain) {
2350         IWineD3DSwapChain_Release(swapChain);
2351     }
2352     HeapFree(GetProcessHeap(), 0, allocatedMemory);
2353     return WINED3D_OK;
2354 }
2355
2356 /**
2357  *   Slightly inefficient way to handle multiple dirty rects but it works :)
2358  */
2359 extern HRESULT WINAPI IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface *iface, CONST RECT* pDirtyRect) {
2360     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2361     IWineD3DBaseTexture *baseTexture = NULL;
2362     if (!(This->Flags & SFLAG_INSYSMEM) && (This->Flags & SFLAG_INTEXTURE))
2363         surface_download_data(This);
2364
2365     This->Flags &= ~(SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
2366     if (NULL != pDirtyRect) {
2367         This->dirtyRect.left   = min(This->dirtyRect.left,   pDirtyRect->left);
2368         This->dirtyRect.top    = min(This->dirtyRect.top,    pDirtyRect->top);
2369         This->dirtyRect.right  = max(This->dirtyRect.right,  pDirtyRect->right);
2370         This->dirtyRect.bottom = max(This->dirtyRect.bottom, pDirtyRect->bottom);
2371     } else {
2372         This->dirtyRect.left   = 0;
2373         This->dirtyRect.top    = 0;
2374         This->dirtyRect.right  = This->currentDesc.Width;
2375         This->dirtyRect.bottom = This->currentDesc.Height;
2376     }
2377     TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This, This->dirtyRect.left,
2378           This->dirtyRect.top, This->dirtyRect.right, This->dirtyRect.bottom);
2379     /* if the container is a basetexture then mark it dirty. */
2380     if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
2381         TRACE("Passing to container\n");
2382         IWineD3DBaseTexture_SetDirty(baseTexture, TRUE);
2383         IWineD3DBaseTexture_Release(baseTexture);
2384     }
2385     return WINED3D_OK;
2386 }
2387
2388 HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) {
2389     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2390     HRESULT hr;
2391     const GlPixelFormatDesc *glDesc;
2392     getFormatDescEntry(format, &GLINFO_LOCATION, &glDesc);
2393
2394     TRACE("(%p) : Calling base function first\n", This);
2395     hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2396     if(SUCCEEDED(hr)) {
2397         /* Setup some glformat defaults */
2398         This->glDescription.glFormat         = glDesc->glFormat;
2399         This->glDescription.glFormatInternal = glDesc->glInternal;
2400         This->glDescription.glType           = glDesc->glType;
2401
2402         This->Flags &= ~SFLAG_ALLOCATED;
2403         TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This,
2404               This->glDescription.glFormat, This->glDescription.glFormatInternal, This->glDescription.glType);
2405     }
2406     return hr;
2407 }
2408
2409 HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2410     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2411
2412     if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
2413         WARN("Surface is locked or the HDC is in use\n");
2414         return WINED3DERR_INVALIDCALL;
2415     }
2416
2417     if(Mem && Mem != This->resource.allocatedMemory) {
2418         void *release = NULL;
2419
2420         /* Do I have to copy the old surface content? */
2421         if(This->Flags & SFLAG_DIBSECTION) {
2422                 /* Release the DC. No need to hold the critical section for the update
2423                  * Thread because this thread runs only on front buffers, but this method
2424                  * fails for render targets in the check above.
2425                  */
2426                 SelectObject(This->hDC, This->dib.holdbitmap);
2427                 DeleteDC(This->hDC);
2428                 /* Release the DIB section */
2429                 DeleteObject(This->dib.DIBsection);
2430                 This->dib.bitmap_data = NULL;
2431                 This->resource.allocatedMemory = NULL;
2432                 This->hDC = NULL;
2433                 This->Flags &= ~SFLAG_DIBSECTION;
2434         } else if(!(This->Flags & SFLAG_USERPTR)) {
2435             release = This->resource.allocatedMemory;
2436         }
2437         This->resource.allocatedMemory = Mem;
2438         This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
2439
2440         /* Now the surface memory is most up do date. Invalidate drawable and texture */
2441         This->Flags &= ~(SFLAG_INDRAWABLE | SFLAG_INTEXTURE);
2442
2443         /* For client textures opengl has to be notified */
2444         if(This->Flags & SFLAG_CLIENT) {
2445             This->Flags &= ~SFLAG_ALLOCATED;
2446             IWineD3DSurface_PreLoad(iface);
2447             /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2448         }
2449
2450         /* Now free the old memory if any */
2451         HeapFree(GetProcessHeap(), 0, release);
2452     } else if(This->Flags & SFLAG_USERPTR) {
2453         /* Lockrect and GetDC will re-create the dib section and allocated memory */
2454         This->resource.allocatedMemory = NULL;
2455         This->Flags &= ~SFLAG_USERPTR;
2456
2457         if(This->Flags & SFLAG_CLIENT) {
2458             This->Flags &= ~SFLAG_ALLOCATED;
2459             /* This respecifies an empty texture and opengl knows that the old memory is gone */
2460             IWineD3DSurface_PreLoad(iface);
2461         }
2462     }
2463     return WINED3D_OK;
2464 }
2465
2466 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD Flags) {
2467     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2468     IWineD3DSwapChainImpl *swapchain = NULL;
2469     HRESULT hr;
2470     TRACE("(%p)->(%p,%x)\n", This, override, Flags);
2471
2472     /* Flipping is only supported on RenderTargets */
2473     if( !(This->resource.usage & WINED3DUSAGE_RENDERTARGET) ) return WINEDDERR_NOTFLIPPABLE;
2474
2475     if(override) {
2476         /* DDraw sets this for the X11 surfaces, so don't confuse the user
2477          * FIXME("(%p) Target override is not supported by now\n", This);
2478          * Additionally, it isn't really possible to support triple-buffering
2479          * properly on opengl at all
2480          */
2481     }
2482
2483     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **) &swapchain);
2484     if(!swapchain) {
2485         ERR("Flipped surface is not on a swapchain\n");
2486         return WINEDDERR_NOTFLIPPABLE;
2487     }
2488
2489     /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2490      * and only d3d8 and d3d9 apps specify the presentation interval
2491      */
2492     if((Flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)) == 0) {
2493         /* Most common case first to avoid wasting time on all the other cases */
2494         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
2495     } else if(Flags & WINEDDFLIP_NOVSYNC) {
2496         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2497     } else if(Flags & WINEDDFLIP_INTERVAL2) {
2498         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
2499     } else if(Flags & WINEDDFLIP_INTERVAL3) {
2500         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
2501     } else {
2502         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
2503     }
2504
2505     /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2506     hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *) swapchain, NULL, NULL, 0, NULL, 0);
2507     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
2508     return hr;
2509 }
2510
2511 /* Does a direct frame buffer -> texture copy. Stretching is done
2512  * with single pixel copy calls
2513  */
2514 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface, IWineD3DSwapChainImpl *swapchain, WINED3DRECT *srect, WINED3DRECT *drect, BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter) {
2515     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2516     float xrel, yrel;
2517     UINT row;
2518     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2519
2520
2521     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2522     ENTER_GL();
2523     IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
2524
2525     /* Bind the target texture */
2526     glBindTexture(GL_TEXTURE_2D, This->glDescription.textureName);
2527     checkGLcall("glBindTexture");
2528     if(!swapchain) {
2529         glReadBuffer(myDevice->offscreenBuffer);
2530     } else {
2531         GLenum buffer = surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain);
2532         glReadBuffer(buffer);
2533     }
2534     checkGLcall("glReadBuffer");
2535
2536     xrel = (float) (srect->x2 - srect->x1) / (float) (drect->x2 - drect->x1);
2537     yrel = (float) (srect->y2 - srect->y1) / (float) (drect->y2 - drect->y1);
2538
2539     if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2540         FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2541
2542         if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
2543             ERR("Texture filtering not supported in direct blit\n");
2544         }
2545     } else if((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) && ((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2546         ERR("Texture filtering not supported in direct blit\n");
2547     }
2548
2549     if(upsidedown &&
2550        !((xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) &&
2551        !((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2552         /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2553
2554         glCopyTexSubImage2D(This->glDescription.target,
2555                             This->glDescription.level,
2556                             drect->x1, drect->y1, /* xoffset, yoffset */
2557                             srect->x1, Src->currentDesc.Height - srect->y2,
2558                             drect->x2 - drect->x1, drect->y2 - drect->y1);
2559     } else {
2560         UINT yoffset = Src->currentDesc.Height - srect->y1 + drect->y1 - 1;
2561         /* I have to process this row by row to swap the image,
2562          * otherwise it would be upside down, so stretching in y direction
2563          * doesn't cost extra time
2564          *
2565          * However, stretching in x direction can be avoided if not necessary
2566          */
2567         for(row = drect->y1; row < drect->y2; row++) {
2568             if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2569                 /* Well, that stuff works, but it's very slow.
2570                  * find a better way instead
2571                  */
2572                 UINT col;
2573
2574                 for(col = drect->x1; col < drect->x2; col++) {
2575                     glCopyTexSubImage2D(This->glDescription.target,
2576                                         This->glDescription.level,
2577                                         drect->x1 + col, row, /* xoffset, yoffset */
2578                                         srect->x1 + col * xrel, yoffset - (int) (row * yrel),
2579                                         1, 1);
2580                 }
2581             } else {
2582                 glCopyTexSubImage2D(This->glDescription.target,
2583                                     This->glDescription.level,
2584                                     drect->x1, row, /* xoffset, yoffset */
2585                                     srect->x1, yoffset - (int) (row * yrel),
2586                                     drect->x2-drect->x1, 1);
2587             }
2588         }
2589     }
2590
2591     vcheckGLcall("glCopyTexSubImage2D");
2592     LEAVE_GL();
2593 }
2594
2595 /* Uses the hardware to stretch and flip the image */
2596 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface, IWineD3DSwapChainImpl *swapchain, WINED3DRECT *srect, WINED3DRECT *drect, BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter) {
2597     GLuint src, backup = 0;
2598     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2599     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2600     float left, right, top, bottom; /* Texture coordinates */
2601     UINT fbwidth = Src->currentDesc.Width;
2602     UINT fbheight = Src->currentDesc.Height;
2603     GLenum drawBuffer = GL_BACK;
2604
2605     TRACE("Using hwstretch blit\n");
2606     /* Activate the Proper context for reading from the source surface, set it up for blitting */
2607     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2608     ENTER_GL();
2609     IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
2610
2611     /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2612      * This way we don't have to wait for the 2nd readback to finish to leave this function.
2613      */
2614     if(GL_LIMITS(aux_buffers) >= 2) {
2615         /* Got more than one aux buffer? Use the 2nd aux buffer */
2616         drawBuffer = GL_AUX1;
2617     } else if((swapchain || myDevice->offscreenBuffer == GL_BACK) && GL_LIMITS(aux_buffers) >= 1) {
2618         /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2619         drawBuffer = GL_AUX0;
2620     }
2621
2622     if(!swapchain && wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
2623         glGenTextures(1, &backup);
2624         checkGLcall("glGenTextures\n");
2625         glBindTexture(GL_TEXTURE_2D, backup);
2626         checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2627     } else {
2628         /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2629          * we are reading from the back buffer, the backup can be used as source texture
2630          */
2631         if(Src->glDescription.textureName == 0) {
2632             /* Get it a description */
2633             IWineD3DSurface_PreLoad(SrcSurface);
2634         }
2635         glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName);
2636         checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2637
2638         /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2639         Src->Flags &= ~SFLAG_INTEXTURE;
2640     }
2641
2642     glReadBuffer(GL_BACK);
2643     checkGLcall("glReadBuffer(GL_BACK)");
2644
2645     /* TODO: Only back up the part that will be overwritten */
2646     glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
2647                         0, 0 /* read offsets */,
2648                         0, 0,
2649                         fbwidth,
2650                         fbheight);
2651
2652     checkGLcall("glCopyTexSubImage2D");
2653
2654     /* No issue with overriding these - the sampler is dirty due to blit usage */
2655     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
2656                     stateLookup[WINELOOKUP_MAGFILTER][Filter - minLookup[WINELOOKUP_MAGFILTER]]);
2657     checkGLcall("glTexParameteri");
2658     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
2659                     minMipLookup[Filter][WINED3DTEXF_NONE]);
2660     checkGLcall("glTexParameteri");
2661
2662     if(!swapchain || (IWineD3DSurface *) Src == swapchain->backBuffer[0]) {
2663         src = backup ? backup : Src->glDescription.textureName;
2664     } else {
2665         glReadBuffer(GL_FRONT);
2666         checkGLcall("glReadBuffer(GL_FRONT)");
2667
2668         glGenTextures(1, &src);
2669         checkGLcall("glGenTextures(1, &src)");
2670         glBindTexture(GL_TEXTURE_2D, src);
2671         checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2672
2673         /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2674          * out for power of 2 sizes
2675          */
2676         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Src->pow2Width, Src->pow2Height, 0,
2677                     GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2678         checkGLcall("glTexImage2D");
2679         glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
2680                             0, 0 /* read offsets */,
2681                             0, 0,
2682                             fbwidth,
2683                             fbheight);
2684
2685         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2686         checkGLcall("glTexParameteri");
2687         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2688         checkGLcall("glTexParameteri");
2689
2690         glReadBuffer(GL_BACK);
2691         checkGLcall("glReadBuffer(GL_BACK)");
2692     }
2693     checkGLcall("glEnd and previous");
2694
2695     left = (float) srect->x1 / (float) Src->pow2Width;
2696     right = (float) srect->x2 / (float) Src->pow2Width;
2697
2698     if(upsidedown) {
2699         top = (float) (Src->currentDesc.Height - srect->y1) / (float) Src->pow2Height;
2700         bottom = (float) (Src->currentDesc.Height - srect->y2) / (float) Src->pow2Height;
2701     } else {
2702         top = (float) (Src->currentDesc.Height - srect->y2) / (float) Src->pow2Height;
2703         bottom = (float) (Src->currentDesc.Height - srect->y1) / (float) Src->pow2Height;
2704     }
2705
2706     /* draw the source texture stretched and upside down. The correct surface is bound already */
2707     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2708     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2709
2710     glDrawBuffer(drawBuffer);
2711     glReadBuffer(drawBuffer);
2712
2713     glBegin(GL_QUADS);
2714         /* bottom left */
2715         glTexCoord2f(left, bottom);
2716         glVertex2i(0, fbheight);
2717
2718         /* top left */
2719         glTexCoord2f(left, top);
2720         glVertex2i(0, fbheight - drect->y2 - drect->y1);
2721
2722         /* top right */
2723         glTexCoord2f(right, top);
2724         glVertex2i(drect->x2 - drect->x1, fbheight - drect->y2 - drect->y1);
2725
2726         /* bottom right */
2727         glTexCoord2f(right, bottom);
2728         glVertex2i(drect->x2 - drect->x1, fbheight);
2729     glEnd();
2730     checkGLcall("glEnd and previous");
2731
2732     /* Now read the stretched and upside down image into the destination texture */
2733     glBindTexture(This->glDescription.target, This->glDescription.textureName);
2734     checkGLcall("glBindTexture");
2735     glCopyTexSubImage2D(This->glDescription.target,
2736                         0,
2737                         drect->x1, drect->y1, /* xoffset, yoffset */
2738                         0, 0, /* We blitted the image to the origin */
2739                         drect->x2 - drect->x1, drect->y2 - drect->y1);
2740     checkGLcall("glCopyTexSubImage2D");
2741
2742     /* Write the back buffer backup back */
2743     glBindTexture(GL_TEXTURE_2D, backup ? backup : Src->glDescription.textureName);
2744     checkGLcall("glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName)");
2745
2746     if(drawBuffer == GL_BACK) {
2747         glBegin(GL_QUADS);
2748             /* top left */
2749             glTexCoord2f(0.0, (float) fbheight / (float) Src->pow2Height);
2750             glVertex2i(0, 0);
2751
2752             /* bottom left */
2753             glTexCoord2f(0.0, 0.0);
2754             glVertex2i(0, fbheight);
2755
2756             /* bottom right */
2757             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, 0.0);
2758             glVertex2i(fbwidth, Src->currentDesc.Height);
2759
2760             /* top right */
2761             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, (float) fbheight / (float) Src->pow2Height);
2762             glVertex2i(fbwidth, 0);
2763         glEnd();
2764     } else {
2765         /* Restore the old draw buffer */
2766         glDrawBuffer(GL_BACK);
2767     }
2768
2769     /* Cleanup */
2770     if(src != Src->glDescription.textureName && src != backup) {
2771         glDeleteTextures(1, &src);
2772         checkGLcall("glDeleteTextures(1, &src)");
2773     }
2774     if(backup) {
2775         glDeleteTextures(1, &backup);
2776         checkGLcall("glDeleteTextures(1, &backup)");
2777     }
2778     LEAVE_GL();
2779 }
2780
2781 /* Not called from the VTable */
2782 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
2783     WINED3DRECT rect;
2784     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2785     IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
2786     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2787
2788     TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
2789
2790     /* Get the swapchain. One of the surfaces has to be a primary surface */
2791     if(This->resource.pool == WINED3DPOOL_SYSTEMMEM) {
2792         WARN("Destination is in sysmem, rejecting gl blt\n");
2793         return WINED3DERR_INVALIDCALL;
2794     }
2795     IWineD3DSurface_GetContainer( (IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&dstSwapchain);
2796     if(dstSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) dstSwapchain);
2797     if(Src) {
2798         if(Src->resource.pool == WINED3DPOOL_SYSTEMMEM) {
2799             WARN("Src is in sysmem, rejecting gl blt\n");
2800             return WINED3DERR_INVALIDCALL;
2801         }
2802         IWineD3DSurface_GetContainer( (IWineD3DSurface *) Src, &IID_IWineD3DSwapChain, (void **)&srcSwapchain);
2803         if(srcSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) srcSwapchain);
2804     }
2805
2806     /* Early sort out of cases where no render target is used */
2807     if(!dstSwapchain && !srcSwapchain &&
2808         SrcSurface != myDevice->render_targets[0] && This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
2809         TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src, This);
2810         return WINED3DERR_INVALIDCALL;
2811     }
2812
2813     /* No destination color keying supported */
2814     if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
2815         /* Can we support that with glBlendFunc if blitting to the frame buffer? */
2816         TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
2817         return WINED3DERR_INVALIDCALL;
2818     }
2819
2820     if (DestRect) {
2821         rect.x1 = DestRect->left;
2822         rect.y1 = DestRect->top;
2823         rect.x2 = DestRect->right;
2824         rect.y2 = DestRect->bottom;
2825     } else {
2826         rect.x1 = 0;
2827         rect.y1 = 0;
2828         rect.x2 = This->currentDesc.Width;
2829         rect.y2 = This->currentDesc.Height;
2830     }
2831
2832     /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
2833     if(dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->backBuffer &&
2834        ((IWineD3DSurface *) This == dstSwapchain->frontBuffer) && SrcSurface == dstSwapchain->backBuffer[0]) {
2835         /* Half-life does a Blt from the back buffer to the front buffer,
2836          * Full surface size, no flags... Use present instead
2837          *
2838          * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
2839          */
2840
2841         /* Check rects - IWineD3DDevice_Present doesn't handle them */
2842         while(1)
2843         {
2844             RECT mySrcRect;
2845             TRACE("Looking if a Present can be done...\n");
2846             /* Source Rectangle must be full surface */
2847             if( SrcRect ) {
2848                 if(SrcRect->left != 0 || SrcRect->top != 0 ||
2849                    SrcRect->right != Src->currentDesc.Width || SrcRect->bottom != Src->currentDesc.Height) {
2850                     TRACE("No, Source rectangle doesn't match\n");
2851                     break;
2852                 }
2853             }
2854             mySrcRect.left = 0;
2855             mySrcRect.top = 0;
2856             mySrcRect.right = Src->currentDesc.Width;
2857             mySrcRect.bottom = Src->currentDesc.Height;
2858
2859             /* No stretching may occur */
2860             if(mySrcRect.right != rect.x2 - rect.x1 ||
2861                mySrcRect.bottom != rect.y2 - rect.y1) {
2862                 TRACE("No, stretching is done\n");
2863                 break;
2864             }
2865
2866             /* Destination must be full surface or match the clipping rectangle */
2867             if(This->clipper && ((IWineD3DClipperImpl *) This->clipper)->hWnd)
2868             {
2869                 RECT cliprect;
2870                 POINT pos[2];
2871                 GetClientRect(((IWineD3DClipperImpl *) This->clipper)->hWnd, &cliprect);
2872                 pos[0].x = rect.x1;
2873                 pos[0].y = rect.y1;
2874                 pos[1].x = rect.x2;
2875                 pos[1].y = rect.y2;
2876                 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl *) This->clipper)->hWnd,
2877                                 pos, 2);
2878
2879                 if(pos[0].x != cliprect.left  || pos[0].y != cliprect.top   ||
2880                    pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
2881                 {
2882                     TRACE("No, dest rectangle doesn't match(clipper)\n");
2883                     TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect.left, cliprect.top, cliprect.right, cliprect.bottom);
2884                     TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect.x1, rect.y1, rect.x2, rect.y2);
2885                     break;
2886                 }
2887             }
2888             else
2889             {
2890                 if(rect.x1 != 0 || rect.y1 != 0 ||
2891                    rect.x2 != This->currentDesc.Width || rect.y2 != This->currentDesc.Height) {
2892                     TRACE("No, dest rectangle doesn't match(surface size)\n");
2893                     break;
2894                 }
2895             }
2896
2897             TRACE("Yes\n");
2898
2899             /* These flags are unimportant for the flag check, remove them */
2900             if((Flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)) == 0) {
2901                 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
2902
2903                 /* The idea behind this is that a glReadPixels and a glDrawPixels call
2904                     * take very long, while a flip is fast.
2905                     * This applies to Half-Life, which does such Blts every time it finished
2906                     * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
2907                     * menu. This is also used by all apps when they do windowed rendering
2908                     *
2909                     * The problem is that flipping is not really the same as copying. After a
2910                     * Blt the front buffer is a copy of the back buffer, and the back buffer is
2911                     * untouched. Therefore it's necessary to override the swap effect
2912                     * and to set it back after the flip.
2913                     *
2914                     * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
2915                     * testcases.
2916                     */
2917
2918                 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
2919                 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2920
2921                 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
2922                 IWineD3DSwapChain_Present((IWineD3DSwapChain *) dstSwapchain, NULL, NULL, 0, NULL, 0);
2923
2924                 dstSwapchain->presentParms.SwapEffect = orig_swap;
2925
2926                 return WINED3D_OK;
2927             }
2928             break;
2929         }
2930
2931         TRACE("Unsupported blit between buffers on the same swapchain\n");
2932         return WINED3DERR_INVALIDCALL;
2933     } else if((dstSwapchain || This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) &&
2934               (srcSwapchain || SrcSurface == myDevice->render_targets[0]) ) {
2935         ERR("Can't perform hardware blit between 2 different swapchains, falling back to software\n");
2936         return WINED3DERR_INVALIDCALL;
2937     }
2938
2939     if(srcSwapchain || SrcSurface == myDevice->render_targets[0]) {
2940         /* Blit from render target to texture */
2941         WINED3DRECT srect;
2942         BOOL upsideDown, stretchx;
2943
2944         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
2945             TRACE("Color keying not supported by frame buffer to texture blit\n");
2946             return WINED3DERR_INVALIDCALL;
2947             /* Destination color key is checked above */
2948         }
2949
2950         /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2951          * glCopyTexSubImage is a bit picky about the parameters we pass to it
2952          */
2953         if(SrcRect) {
2954             if(SrcRect->top < SrcRect->bottom) {
2955                 srect.y1 = SrcRect->top;
2956                 srect.y2 = SrcRect->bottom;
2957                 upsideDown = FALSE;
2958             } else {
2959                 srect.y1 = SrcRect->bottom;
2960                 srect.y2 = SrcRect->top;
2961                 upsideDown = TRUE;
2962             }
2963             srect.x1 = SrcRect->left;
2964             srect.x2 = SrcRect->right;
2965         } else {
2966             srect.x1 = 0;
2967             srect.y1 = 0;
2968             srect.x2 = Src->currentDesc.Width;
2969             srect.y2 = Src->currentDesc.Height;
2970             upsideDown = FALSE;
2971         }
2972         if(rect.x1 > rect.x2) {
2973             UINT tmp = rect.x2;
2974             rect.x2 = rect.x1;
2975             rect.x1 = tmp;
2976             upsideDown = !upsideDown;
2977         }
2978         if(!srcSwapchain) {
2979             TRACE("Reading from an offscreen target\n");
2980             upsideDown = !upsideDown;
2981         }
2982
2983         if(rect.x2 - rect.x1 != srect.x2 - srect.x1) {
2984             stretchx = TRUE;
2985         } else {
2986             stretchx = FALSE;
2987         }
2988
2989         /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
2990          * flip the image nor scale it.
2991          *
2992          * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
2993          * -> If the app wants a image width an unscaled width, copy it line per line
2994          * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
2995          *    than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
2996          *    back buffer. This is slower than reading line per line, thus not used for flipping
2997          * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
2998          *    pixel by pixel
2999          *
3000          * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3001          * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3002          * backends.
3003          */
3004         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT)) {
3005             stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &srect,
3006                     (IWineD3DSurface *)This, &rect, Filter, upsideDown);
3007         } else if((!stretchx) || rect.x2 - rect.x1 > Src->currentDesc.Width ||
3008                                     rect.y2 - rect.y1 > Src->currentDesc.Height) {
3009             TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3010             fb_copy_to_texture_direct(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3011         } else {
3012             TRACE("Using hardware stretching to flip / stretch the texture\n");
3013             fb_copy_to_texture_hwstretch(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3014         }
3015
3016         if(!(This->Flags & SFLAG_DONOTFREE)) {
3017             HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
3018             This->resource.allocatedMemory = NULL;
3019         } else {
3020             This->Flags &= ~SFLAG_INSYSMEM;
3021         }
3022         /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3023          * path is never entered
3024          */
3025         This->Flags |= SFLAG_INTEXTURE;
3026
3027         return WINED3D_OK;
3028     } else if(Src) {
3029         /* Blit from offscreen surface to render target */
3030         float glTexCoord[4];
3031         DWORD oldCKeyFlags = Src->CKeyFlags;
3032         WINEDDCOLORKEY oldBltCKey = This->SrcBltCKey;
3033         RECT SourceRectangle;
3034
3035         TRACE("Blt from surface %p to rendertarget %p\n", Src, This);
3036
3037         if(SrcRect) {
3038             SourceRectangle.left = SrcRect->left;
3039             SourceRectangle.right = SrcRect->right;
3040             SourceRectangle.top = SrcRect->top;
3041             SourceRectangle.bottom = SrcRect->bottom;
3042         } else {
3043             SourceRectangle.left = 0;
3044             SourceRectangle.right = Src->currentDesc.Width;
3045             SourceRectangle.top = 0;
3046             SourceRectangle.bottom = Src->currentDesc.Height;
3047         }
3048
3049         if(!CalculateTexRect(Src, &SourceRectangle, glTexCoord)) {
3050             /* Fall back to software */
3051             WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src,
3052                     SourceRectangle.left, SourceRectangle.top,
3053                     SourceRectangle.right, SourceRectangle.bottom);
3054             return WINED3DERR_INVALIDCALL;
3055         }
3056
3057         /* Color keying: Check if we have to do a color keyed blt,
3058          * and if not check if a color key is activated.
3059          *
3060          * Just modify the color keying parameters in the surface and restore them afterwards
3061          * The surface keeps track of the color key last used to load the opengl surface.
3062          * PreLoad will catch the change to the flags and color key and reload if necessary.
3063          */
3064         if(Flags & WINEDDBLT_KEYSRC) {
3065             /* Use color key from surface */
3066         } else if(Flags & WINEDDBLT_KEYSRCOVERRIDE) {
3067             /* Use color key from DDBltFx */
3068             Src->CKeyFlags |= WINEDDSD_CKSRCBLT;
3069             This->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3070         } else {
3071             /* Do not use color key */
3072             Src->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3073         }
3074
3075         /* Now load the surface */
3076         IWineD3DSurface_PreLoad((IWineD3DSurface *) Src);
3077
3078
3079         /* Activate the destination context, set it up for blitting */
3080         ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
3081         ENTER_GL();
3082
3083         if(!dstSwapchain) {
3084             TRACE("Drawing to offscreen buffer\n");
3085             glDrawBuffer(myDevice->offscreenBuffer);
3086             checkGLcall("glDrawBuffer");
3087         } else {
3088             GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *)This, (IWineD3DSwapChain *)dstSwapchain);
3089             TRACE("Drawing to %#x buffer\n", buffer);
3090             glDrawBuffer(buffer);
3091             checkGLcall("glDrawBuffer");
3092         }
3093
3094         /* Bind the texture */
3095         glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName);
3096         checkGLcall("glBindTexture");
3097
3098         /* Filtering for StretchRect */
3099         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
3100                         stateLookup[WINELOOKUP_MAGFILTER][Filter - minLookup[WINELOOKUP_MAGFILTER]]);
3101         checkGLcall("glTexParameteri");
3102         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
3103                         minMipLookup[Filter][WINED3DTEXF_NONE]);
3104         checkGLcall("glTexParameteri");
3105         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
3106         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
3107         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
3108         checkGLcall("glTexEnvi");
3109
3110         /* This is for color keying */
3111         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3112             glEnable(GL_ALPHA_TEST);
3113             checkGLcall("glEnable GL_ALPHA_TEST");
3114             glAlphaFunc(GL_NOTEQUAL, 0.0);
3115             checkGLcall("glAlphaFunc\n");
3116         } else {
3117             glDisable(GL_ALPHA_TEST);
3118             checkGLcall("glDisable GL_ALPHA_TEST");
3119         }
3120
3121         /* Draw a textured quad
3122          */
3123         glBegin(GL_QUADS);
3124
3125         glColor3d(1.0f, 1.0f, 1.0f);
3126         glTexCoord2f(glTexCoord[0], glTexCoord[2]);
3127         glVertex3f(rect.x1,
3128                     rect.y1,
3129                     0.0);
3130
3131         glTexCoord2f(glTexCoord[0], glTexCoord[3]);
3132         glVertex3f(rect.x1, rect.y2, 0.0);
3133
3134         glTexCoord2f(glTexCoord[1], glTexCoord[3]);
3135         glVertex3f(rect.x2,
3136                     rect.y2,
3137                     0.0);
3138
3139         glTexCoord2f(glTexCoord[1], glTexCoord[2]);
3140         glVertex3f(rect.x2,
3141                     rect.y1,
3142                     0.0);
3143         glEnd();
3144         checkGLcall("glEnd");
3145
3146         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3147             glDisable(GL_ALPHA_TEST);
3148             checkGLcall("glDisable(GL_ALPHA_TEST)");
3149         }
3150
3151         /* Unbind the texture */
3152         glBindTexture(GL_TEXTURE_2D, 0);
3153         checkGLcall("glEnable glBindTexture");
3154
3155         /* The draw buffer should only need to be restored if we were drawing to the front buffer, and there is a back buffer.
3156          * otherwise the context manager should choose between GL_BACK / offscreenDrawBuffer
3157          */
3158         if(dstSwapchain && This == (IWineD3DSurfaceImpl *) dstSwapchain->frontBuffer && dstSwapchain->backBuffer) {
3159             glDrawBuffer(GL_BACK);
3160             checkGLcall("glDrawBuffer");
3161         }
3162         /* Restore the color key parameters */
3163         Src->CKeyFlags = oldCKeyFlags;
3164         This->SrcBltCKey = oldBltCKey;
3165
3166         LEAVE_GL();
3167
3168         /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3169         This->Flags &= ~SFLAG_INSYSMEM;
3170         /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3171          * is outdated now
3172          */
3173         if(dstSwapchain || wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
3174             This->Flags |= SFLAG_INDRAWABLE;
3175             This->Flags &= ~SFLAG_INTEXTURE;
3176         } else {
3177             This->Flags |= SFLAG_INTEXTURE;
3178         }
3179
3180         return WINED3D_OK;
3181     } else {
3182         /* Source-Less Blit to render target */
3183         if (Flags & WINEDDBLT_COLORFILL) {
3184             /* This is easy to handle for the D3D Device... */
3185             DWORD color;
3186
3187             TRACE("Colorfill\n");
3188
3189             /* The color as given in the Blt function is in the format of the frame-buffer...
3190              * 'clear' expect it in ARGB format => we need to do some conversion :-)
3191              */
3192             if (This->resource.format == WINED3DFMT_P8) {
3193                 if (This->palette) {
3194                     color = ((0xFF000000) |
3195                             (This->palette->palents[DDBltFx->u5.dwFillColor].peRed << 16) |
3196                             (This->palette->palents[DDBltFx->u5.dwFillColor].peGreen << 8) |
3197                             (This->palette->palents[DDBltFx->u5.dwFillColor].peBlue));
3198                 } else {
3199                     color = 0xFF000000;
3200                 }
3201             }
3202             else if (This->resource.format == WINED3DFMT_R5G6B5) {
3203                 if (DDBltFx->u5.dwFillColor == 0xFFFF) {
3204                     color = 0xFFFFFFFF;
3205                 } else {
3206                     color = ((0xFF000000) |
3207                             ((DDBltFx->u5.dwFillColor & 0xF800) << 8) |
3208                             ((DDBltFx->u5.dwFillColor & 0x07E0) << 5) |
3209                             ((DDBltFx->u5.dwFillColor & 0x001F) << 3));
3210                 }
3211             }
3212             else if ((This->resource.format == WINED3DFMT_R8G8B8) ||
3213                     (This->resource.format == WINED3DFMT_X8R8G8B8) ) {
3214                 color = 0xFF000000 | DDBltFx->u5.dwFillColor;
3215             }
3216             else if (This->resource.format == WINED3DFMT_A8R8G8B8) {
3217                 color = DDBltFx->u5.dwFillColor;
3218             }
3219             else {
3220                 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3221                 return WINED3DERR_INVALIDCALL;
3222             }
3223
3224             TRACE("Calling GetSwapChain with mydevice = %p\n", myDevice);
3225             if(dstSwapchain && dstSwapchain->backBuffer && This == (IWineD3DSurfaceImpl*) dstSwapchain->backBuffer[0]) {
3226                 glDrawBuffer(GL_BACK);
3227                 checkGLcall("glDrawBuffer(GL_BACK)");
3228             } else if (dstSwapchain && This == (IWineD3DSurfaceImpl*) dstSwapchain->frontBuffer) {
3229                 glDrawBuffer(GL_FRONT);
3230                 checkGLcall("glDrawBuffer(GL_FRONT)");
3231             } else if(This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3232                 glDrawBuffer(myDevice->offscreenBuffer);
3233                 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer3)");
3234             } else {
3235                 TRACE("Surface is higher back buffer, falling back to software\n");
3236                 return WINED3DERR_INVALIDCALL;
3237             }
3238
3239             TRACE("(%p) executing Render Target override, color = %x\n", This, color);
3240
3241             IWineD3DDevice_Clear( (IWineD3DDevice *) myDevice,
3242                                 1 /* Number of rectangles */,
3243                                 &rect,
3244                                 WINED3DCLEAR_TARGET,
3245                                 color,
3246                                 0.0 /* Z */,
3247                                 0 /* Stencil */);
3248
3249             /* Restore the original draw buffer */
3250             if(!dstSwapchain) {
3251                 glDrawBuffer(myDevice->offscreenBuffer);
3252             } else if(dstSwapchain->backBuffer && dstSwapchain->backBuffer[0]) {
3253                 glDrawBuffer(GL_BACK);
3254             }
3255             vcheckGLcall("glDrawBuffer");
3256
3257             return WINED3D_OK;
3258         }
3259     }
3260
3261     /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3262     TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3263     return WINED3DERR_INVALIDCALL;
3264 }
3265
3266 static HRESULT WINAPI IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx)
3267 {
3268     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3269     float depth;
3270
3271     if (Flags & WINEDDBLT_DEPTHFILL) {
3272         switch(This->resource.format) {
3273             case WINED3DFMT_D16:
3274                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
3275                 break;
3276             case WINED3DFMT_D15S1:
3277                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000fffe;
3278                 break;
3279             case WINED3DFMT_D24S8:
3280             case WINED3DFMT_D24X8:
3281                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x00ffffff;
3282                 break;
3283             case WINED3DFMT_D32:
3284                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0xffffffff;
3285                 break;
3286             default:
3287                 depth = 0.0;
3288                 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This->resource.format));
3289         }
3290
3291         return IWineD3DDevice_Clear((IWineD3DDevice *) myDevice,
3292                                     DestRect == NULL ? 0 : 1,
3293                                     (WINED3DRECT *) DestRect,
3294                                     WINED3DCLEAR_ZBUFFER,
3295                                     0x00000000,
3296                                     depth,
3297                                     0x00000000);
3298     }
3299
3300     FIXME("(%p): Unsupp depthstencil blit\n", This);
3301     return WINED3DERR_INVALIDCALL;
3302 }
3303
3304 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
3305     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
3306     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3307     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3308     TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3309     TRACE("(%p): Usage is %s\n", This, debug_d3dusage(This->resource.usage));
3310
3311     /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3312      * except depth blits, which seem to work
3313      */
3314     if(iface == myDevice->stencilBufferTarget || (SrcSurface && SrcSurface == myDevice->stencilBufferTarget)) {
3315         if(myDevice->inScene && !(Flags & WINEDDBLT_DEPTHFILL)) {
3316             TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3317             return WINED3DERR_INVALIDCALL;
3318         } else if(IWineD3DSurfaceImpl_BltZ(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx) == WINED3D_OK) {
3319             TRACE("Z Blit override handled the blit\n");
3320             return WINED3D_OK;
3321         }
3322     }
3323
3324     /* Special cases for RenderTargets */
3325     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3326         ( Src && (Src->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3327         if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
3328     }
3329
3330     /* For the rest call the X11 surface implementation.
3331      * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3332      * other Blts are rather rare
3333      */
3334     return IWineGDISurfaceImpl_Blt(iface, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter);
3335 }
3336
3337 HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans) {
3338     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3339     IWineD3DSurfaceImpl *srcImpl = (IWineD3DSurfaceImpl *) Source;
3340     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3341     TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface, dstx, dsty, Source, rsrc, trans);
3342
3343     if(myDevice->inScene &&
3344        (iface == myDevice->stencilBufferTarget ||
3345        (Source && Source == myDevice->stencilBufferTarget))) {
3346         TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3347         return WINED3DERR_INVALIDCALL;
3348     }
3349
3350     /* Special cases for RenderTargets */
3351     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3352         ( srcImpl && (srcImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3353
3354         RECT SrcRect, DstRect;
3355         DWORD Flags=0;
3356
3357         if(rsrc) {
3358             SrcRect.left = rsrc->left;
3359             SrcRect.top= rsrc->top;
3360             SrcRect.bottom = rsrc->bottom;
3361             SrcRect.right = rsrc->right;
3362         } else {
3363             SrcRect.left = 0;
3364             SrcRect.top = 0;
3365             SrcRect.right = srcImpl->currentDesc.Width;
3366             SrcRect.bottom = srcImpl->currentDesc.Height;
3367         }
3368
3369         DstRect.left = dstx;
3370         DstRect.top=dsty;
3371         DstRect.right = dstx + SrcRect.right - SrcRect.left;
3372         DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
3373
3374         /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3375         if(trans & WINEDDBLTFAST_SRCCOLORKEY)
3376             Flags |= WINEDDBLT_KEYSRC;
3377         if(trans & WINEDDBLTFAST_DESTCOLORKEY)
3378             Flags |= WINEDDBLT_KEYDEST;
3379         if(trans & WINEDDBLTFAST_WAIT)
3380             Flags |= WINEDDBLT_WAIT;
3381         if(trans & WINEDDBLTFAST_DONOTWAIT)
3382             Flags |= WINEDDBLT_DONOTWAIT;
3383
3384         if(IWineD3DSurfaceImpl_BltOverride(This, &DstRect, Source, &SrcRect, Flags, NULL, WINED3DTEXF_POINT) == WINED3D_OK) return WINED3D_OK;
3385     }
3386
3387
3388     return IWineGDISurfaceImpl_BltFast(iface, dstx, dsty, Source, rsrc, trans);
3389 }
3390
3391 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
3392     /** Check against the maximum texture sizes supported by the video card **/
3393     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3394     unsigned int pow2Width, pow2Height;
3395     const GlPixelFormatDesc *glDesc;
3396
3397     getFormatDescEntry(This->resource.format, &GLINFO_LOCATION, &glDesc);
3398     /* Setup some glformat defaults */
3399     This->glDescription.glFormat         = glDesc->glFormat;
3400     This->glDescription.glFormatInternal = glDesc->glInternal;
3401     This->glDescription.glType           = glDesc->glType;
3402
3403     This->glDescription.textureName      = 0;
3404     This->glDescription.target           = GL_TEXTURE_2D;
3405
3406     /* Non-power2 support */
3407     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
3408         pow2Width = This->currentDesc.Width;
3409         pow2Height = This->currentDesc.Height;
3410     } else {
3411         /* Find the nearest pow2 match */
3412         pow2Width = pow2Height = 1;
3413         while (pow2Width < This->currentDesc.Width) pow2Width <<= 1;
3414         while (pow2Height < This->currentDesc.Height) pow2Height <<= 1;
3415     }
3416     This->pow2Width  = pow2Width;
3417     This->pow2Height = pow2Height;
3418
3419     if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
3420         WINED3DFORMAT Format = This->resource.format;
3421         /** TODO: add support for non power two compressed textures **/
3422         if (Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3
3423             || Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) {
3424             FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3425                   This, This->currentDesc.Width, This->currentDesc.Height);
3426             return WINED3DERR_NOTAVAILABLE;
3427         }
3428     }
3429
3430     if(pow2Width != This->currentDesc.Width ||
3431        pow2Height != This->currentDesc.Height) {
3432         This->Flags |= SFLAG_NONPOW2;
3433     }
3434
3435     TRACE("%p\n", This);
3436     if ((This->pow2Width > GL_LIMITS(texture_size) || This->pow2Height > GL_LIMITS(texture_size)) && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))) {
3437         /* one of three options
3438         1: Do the same as we do with nonpow 2 and scale the texture, (any texture ops would require the texture to be scaled which is potentially slow)
3439         2: Set the texture to the maximum size (bad idea)
3440         3:    WARN and return WINED3DERR_NOTAVAILABLE;
3441         4: Create the surface, but allow it to be used only for DirectDraw Blts. Some apps(e.g. Swat 3) create textures with a Height of 16 and a Width > 3000 and blt 16x16 letter areas from them to the render target.
3442         */
3443         WARN("(%p) Creating an oversized surface\n", This);
3444         This->Flags |= SFLAG_OVERSIZE;
3445
3446         /* This will be initialized on the first blt */
3447         This->glRect.left = 0;
3448         This->glRect.top = 0;
3449         This->glRect.right = 0;
3450         This->glRect.bottom = 0;
3451     } else {
3452         /* No oversize, gl rect is the full texture size */
3453         This->Flags &= ~SFLAG_OVERSIZE;
3454         This->glRect.left = 0;
3455         This->glRect.top = 0;
3456         This->glRect.right = This->pow2Width;
3457         This->glRect.bottom = This->pow2Height;
3458     }
3459
3460     if(This->resource.allocatedMemory == NULL) {
3461         /* Make sure memory exists from the start, and it is initialized properly. D3D initializes surfaces,
3462          * gl does not, so we need to upload zeroes to init the gl texture.
3463          */
3464         This->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + 4);
3465     }
3466     This->Flags |= SFLAG_INSYSMEM;
3467
3468     return WINED3D_OK;
3469 }
3470
3471 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
3472 {
3473     /* IUnknown */
3474     IWineD3DBaseSurfaceImpl_QueryInterface,
3475     IWineD3DBaseSurfaceImpl_AddRef,
3476     IWineD3DSurfaceImpl_Release,
3477     /* IWineD3DResource */
3478     IWineD3DBaseSurfaceImpl_GetParent,
3479     IWineD3DBaseSurfaceImpl_GetDevice,
3480     IWineD3DBaseSurfaceImpl_SetPrivateData,
3481     IWineD3DBaseSurfaceImpl_GetPrivateData,
3482     IWineD3DBaseSurfaceImpl_FreePrivateData,
3483     IWineD3DBaseSurfaceImpl_SetPriority,
3484     IWineD3DBaseSurfaceImpl_GetPriority,
3485     IWineD3DSurfaceImpl_PreLoad,
3486     IWineD3DBaseSurfaceImpl_GetType,
3487     /* IWineD3DSurface */
3488     IWineD3DBaseSurfaceImpl_GetContainer,
3489     IWineD3DBaseSurfaceImpl_GetDesc,
3490     IWineD3DSurfaceImpl_LockRect,
3491     IWineD3DSurfaceImpl_UnlockRect,
3492     IWineD3DSurfaceImpl_GetDC,
3493     IWineD3DSurfaceImpl_ReleaseDC,
3494     IWineD3DSurfaceImpl_Flip,
3495     IWineD3DSurfaceImpl_Blt,
3496     IWineD3DBaseSurfaceImpl_GetBltStatus,
3497     IWineD3DBaseSurfaceImpl_GetFlipStatus,
3498     IWineD3DBaseSurfaceImpl_IsLost,
3499     IWineD3DBaseSurfaceImpl_Restore,
3500     IWineD3DSurfaceImpl_BltFast,
3501     IWineD3DBaseSurfaceImpl_GetPalette,
3502     IWineD3DBaseSurfaceImpl_SetPalette,
3503     IWineD3DBaseSurfaceImpl_RealizePalette,
3504     IWineD3DBaseSurfaceImpl_SetColorKey,
3505     IWineD3DBaseSurfaceImpl_GetPitch,
3506     IWineD3DSurfaceImpl_SetMem,
3507     IWineD3DBaseSurfaceImpl_SetOverlayPosition,
3508     IWineD3DBaseSurfaceImpl_GetOverlayPosition,
3509     IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
3510     IWineD3DBaseSurfaceImpl_UpdateOverlay,
3511     IWineD3DBaseSurfaceImpl_SetClipper,
3512     IWineD3DBaseSurfaceImpl_GetClipper,
3513     /* Internal use: */
3514     IWineD3DSurfaceImpl_AddDirtyRect,
3515     IWineD3DSurfaceImpl_LoadTexture,
3516     IWineD3DSurfaceImpl_SaveSnapshot,
3517     IWineD3DBaseSurfaceImpl_SetContainer,
3518     IWineD3DSurfaceImpl_SetGlTextureDesc,
3519     IWineD3DSurfaceImpl_GetGlDesc,
3520     IWineD3DSurfaceImpl_GetData,
3521     IWineD3DSurfaceImpl_SetFormat,
3522     IWineD3DSurfaceImpl_PrivateSetup
3523 };