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     UINT usage;
1300     BITMAPINFO* b_info;
1301     HDC ddc;
1302     DWORD *masks;
1303     HRESULT hr;
1304     RGBQUAD col[256];
1305     const StaticPixelFormatDesc *formatEntry = getFormatDescEntry(This->resource.format, NULL, NULL);
1306
1307     TRACE("(%p)->(%p)\n",This,pHDC);
1308
1309     if(This->Flags & SFLAG_USERPTR) {
1310         ERR("Not supported on surfaces with an application-provided surfaces\n");
1311         return WINEDDERR_NODC;
1312     }
1313
1314     /* Give more detailed info for ddraw */
1315     if (This->Flags & SFLAG_DCINUSE)
1316         return WINEDDERR_DCALREADYCREATED;
1317
1318     /* Can't GetDC if the surface is locked */
1319     if (This->Flags & SFLAG_LOCKED)
1320         return WINED3DERR_INVALIDCALL;
1321
1322     memset(&lock, 0, sizeof(lock)); /* To be sure */
1323
1324     /* Create a DIB section if there isn't a hdc yet */
1325     if(!This->hDC) {
1326         int extraline = 0;
1327         SYSTEM_INFO sysInfo;
1328         void *oldmem = This->resource.allocatedMemory;
1329
1330         switch (This->bytesPerPixel) {
1331             case 2:
1332             case 4:
1333                 /* Allocate extra space to store the RGB bit masks. */
1334                 b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 3 * sizeof(DWORD));
1335                 break;
1336
1337             case 3:
1338                 b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER));
1339                 break;
1340
1341             default:
1342                 /* Allocate extra space for a palette. */
1343                 b_info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1344                                   sizeof(BITMAPINFOHEADER)
1345                                   + sizeof(RGBQUAD)
1346                                   * (1 << (This->bytesPerPixel * 8)));
1347                 break;
1348         }
1349
1350         if (!b_info)
1351             return E_OUTOFMEMORY;
1352
1353         /* Some apps access the surface in via DWORDs, and do not take the necessary care at the end of the
1354          * surface. So we need at least extra 4 bytes at the end of the surface. Check against the page size,
1355          * if the last page used for the surface has at least 4 spare bytes we're safe, otherwise
1356          * add an extra line to the dib section
1357          */
1358         GetSystemInfo(&sysInfo);
1359         if( ((This->resource.size + 3) % sysInfo.dwPageSize) < 4) {
1360             extraline = 1;
1361             TRACE("Adding an extra line to the dib section\n");
1362         }
1363
1364         b_info->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1365         /* TODO: Is there a nicer way to force a specific alignment? (8 byte for ddraw) */
1366         b_info->bmiHeader.biWidth = IWineD3DSurface_GetPitch(iface) / This->bytesPerPixel;
1367         b_info->bmiHeader.biHeight = -This->currentDesc.Height -extraline;
1368         b_info->bmiHeader.biSizeImage = ( This->currentDesc.Height + extraline) * IWineD3DSurface_GetPitch(iface);
1369         b_info->bmiHeader.biPlanes = 1;
1370         b_info->bmiHeader.biBitCount = This->bytesPerPixel * 8;
1371
1372         b_info->bmiHeader.biXPelsPerMeter = 0;
1373         b_info->bmiHeader.biYPelsPerMeter = 0;
1374         b_info->bmiHeader.biClrUsed = 0;
1375         b_info->bmiHeader.biClrImportant = 0;
1376
1377         /* Get the bit masks */
1378         masks = (DWORD *) &(b_info->bmiColors);
1379         switch (This->resource.format) {
1380             case WINED3DFMT_R8G8B8:
1381                 usage = DIB_RGB_COLORS;
1382                 b_info->bmiHeader.biCompression = BI_RGB;
1383                 break;
1384
1385             case WINED3DFMT_X1R5G5B5:
1386             case WINED3DFMT_A1R5G5B5:
1387             case WINED3DFMT_A4R4G4B4:
1388             case WINED3DFMT_X4R4G4B4:
1389             case WINED3DFMT_R3G3B2:
1390             case WINED3DFMT_A8R3G3B2:
1391             case WINED3DFMT_A2B10G10R10:
1392             case WINED3DFMT_A8B8G8R8:
1393             case WINED3DFMT_X8B8G8R8:
1394             case WINED3DFMT_A2R10G10B10:
1395             case WINED3DFMT_R5G6B5:
1396             case WINED3DFMT_A16B16G16R16:
1397                 usage = 0;
1398                 b_info->bmiHeader.biCompression = BI_BITFIELDS;
1399                 masks[0] = formatEntry->redMask;
1400                 masks[1] = formatEntry->greenMask;
1401                 masks[2] = formatEntry->blueMask;
1402                 break;
1403
1404             default:
1405                 /* Don't know palette */
1406                 b_info->bmiHeader.biCompression = BI_RGB;
1407                 usage = 0;
1408                 break;
1409         }
1410
1411         ddc = GetDC(0);
1412         if (ddc == 0) {
1413             HeapFree(GetProcessHeap(), 0, b_info);
1414             return HRESULT_FROM_WIN32(GetLastError());
1415         }
1416
1417         TRACE("Creating a DIB section with size %dx%dx%d, size=%d\n", b_info->bmiHeader.biWidth, b_info->bmiHeader.biHeight, b_info->bmiHeader.biBitCount, b_info->bmiHeader.biSizeImage);
1418         This->dib.DIBsection = CreateDIBSection(ddc, b_info, usage, &This->dib.bitmap_data, 0 /* Handle */, 0 /* Offset */);
1419         ReleaseDC(0, ddc);
1420
1421         if (!This->dib.DIBsection) {
1422             ERR("CreateDIBSection failed!\n");
1423             HeapFree(GetProcessHeap(), 0, b_info);
1424             return HRESULT_FROM_WIN32(GetLastError());
1425         }
1426
1427         TRACE("DIBSection at : %p\n", This->dib.bitmap_data);
1428         /* copy the existing surface to the dib section */
1429         if(This->resource.allocatedMemory) {
1430             /* In case of a PBO, allocatedMemory=NULL, it isn't NULL between a LockRect and a UnlockRect */
1431             if(!(This->Flags & SFLAG_PBO))
1432                 memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, b_info->bmiHeader.biSizeImage);
1433             /* We won't need that any more */
1434         } else {
1435             /* This is to make LockRect read the gl Texture although memory is allocated */
1436             This->Flags &= ~SFLAG_INSYSMEM;
1437         }
1438         This->dib.bitmap_size = b_info->bmiHeader.biSizeImage;
1439
1440         HeapFree(GetProcessHeap(), 0, b_info);
1441
1442         /* Use the dib section from now on if we are not using a PBO */
1443         if(!(This->Flags & SFLAG_PBO))
1444             This->resource.allocatedMemory = This->dib.bitmap_data;
1445
1446         /* Now allocate a HDC */
1447         This->hDC = CreateCompatibleDC(0);
1448         This->dib.holdbitmap = SelectObject(This->hDC, This->dib.DIBsection);
1449         TRACE("using wined3d palette %p\n", This->palette);
1450         SelectPalette(This->hDC,
1451                       This->palette ? This->palette->hpal : 0,
1452                       FALSE);
1453
1454         This->Flags |= SFLAG_DIBSECTION;
1455
1456         if(This->Flags & SFLAG_CLIENT) {
1457             IWineD3DSurface_PreLoad(iface);
1458         }
1459         HeapFree(GetProcessHeap(), 0, oldmem);
1460     }
1461
1462     /* Lock the surface */
1463     hr = IWineD3DSurface_LockRect(iface,
1464                                   &lock,
1465                                   NULL,
1466                                   0);
1467
1468     if(This->Flags & SFLAG_PBO) {
1469         /* Sync the DIB with the PBO. This can't be done earlier because LockRect activates the allocatedMemory */
1470         memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
1471     }
1472
1473     if(FAILED(hr)) {
1474         ERR("IWineD3DSurface_LockRect failed with hr = %08x\n", hr);
1475         /* keep the dib section */
1476         return hr;
1477     }
1478
1479     if(This->resource.format == WINED3DFMT_P8 ||
1480         This->resource.format == WINED3DFMT_A8P8) {
1481         unsigned int n;
1482         if(This->palette) {
1483             PALETTEENTRY ent[256];
1484
1485             GetPaletteEntries(This->palette->hpal, 0, 256, ent);
1486             for (n=0; n<256; n++) {
1487                 col[n].rgbRed   = ent[n].peRed;
1488                 col[n].rgbGreen = ent[n].peGreen;
1489                 col[n].rgbBlue  = ent[n].peBlue;
1490                 col[n].rgbReserved = 0;
1491             }
1492         } else {
1493             IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1494
1495             for (n=0; n<256; n++) {
1496                 col[n].rgbRed   = device->palettes[device->currentPalette][n].peRed;
1497                 col[n].rgbGreen = device->palettes[device->currentPalette][n].peGreen;
1498                 col[n].rgbBlue  = device->palettes[device->currentPalette][n].peBlue;
1499                 col[n].rgbReserved = 0;
1500             }
1501
1502         }
1503         SetDIBColorTable(This->hDC, 0, 256, col);
1504     }
1505
1506     *pHDC = This->hDC;
1507     TRACE("returning %p\n",*pHDC);
1508     This->Flags |= SFLAG_DCINUSE;
1509
1510     return WINED3D_OK;
1511 }
1512
1513 HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC) {
1514     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1515
1516     TRACE("(%p)->(%p)\n",This,hDC);
1517
1518     if (!(This->Flags & SFLAG_DCINUSE))
1519         return WINED3DERR_INVALIDCALL;
1520
1521     if (This->hDC !=hDC) {
1522         WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
1523         return WINED3DERR_INVALIDCALL;
1524     }
1525
1526     if((This->Flags & SFLAG_PBO) && This->resource.allocatedMemory) {
1527         /* Copy the contents of the DIB over to the PBO */
1528         memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
1529     }
1530
1531     /* we locked first, so unlock now */
1532     IWineD3DSurface_UnlockRect(iface);
1533
1534     This->Flags &= ~SFLAG_DCINUSE;
1535
1536     return WINED3D_OK;
1537 }
1538
1539 /* ******************************************************
1540    IWineD3DSurface Internal (No mapping to directx api) parts follow
1541    ****************************************************** */
1542
1543 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) {
1544     BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
1545     const GlPixelFormatDesc *glDesc;
1546     getFormatDescEntry(This->resource.format, &GLINFO_LOCATION, &glDesc);
1547
1548     /* Default values: From the surface */
1549     *format = glDesc->glFormat;
1550     *internal = srgb_mode?glDesc->glGammaInternal:glDesc->glInternal;
1551     *type = glDesc->glType;
1552     *convert = NO_CONVERSION;
1553     *target_bpp = This->bytesPerPixel;
1554
1555     /* Ok, now look if we have to do any conversion */
1556     switch(This->resource.format) {
1557         case WINED3DFMT_P8:
1558             /* ****************
1559                 Paletted Texture
1560                 **************** */
1561             /* Use conversion when the paletted texture extension is not available, or when it is available make sure it is used
1562              * for texturing as it won't work for calls like glDraw-/glReadPixels and further also use conversion in case of color keying.
1563              */
1564             if(!GL_SUPPORT(EXT_PALETTED_TEXTURE) || colorkey_active || (!use_texturing && GL_SUPPORT(EXT_PALETTED_TEXTURE)) ) {
1565                 *format = GL_RGBA;
1566                 *internal = GL_RGBA;
1567                 *type = GL_UNSIGNED_BYTE;
1568                 *target_bpp = 4;
1569                 if(colorkey_active) {
1570                     *convert = CONVERT_PALETTED_CK;
1571                 } else {
1572                     *convert = CONVERT_PALETTED;
1573                 }
1574             }
1575
1576             break;
1577
1578         case WINED3DFMT_R3G3B2:
1579             /* **********************
1580                 GL_UNSIGNED_BYTE_3_3_2
1581                 ********************** */
1582             if (colorkey_active) {
1583                 /* This texture format will never be used.. So do not care about color keying
1584                     up until the point in time it will be needed :-) */
1585                 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
1586             }
1587             break;
1588
1589         case WINED3DFMT_R5G6B5:
1590             if (colorkey_active) {
1591                 *convert = CONVERT_CK_565;
1592                 *format = GL_RGBA;
1593                 *internal = GL_RGBA;
1594                 *type = GL_UNSIGNED_SHORT_5_5_5_1;
1595             }
1596             break;
1597
1598         case WINED3DFMT_X1R5G5B5:
1599             if (colorkey_active) {
1600                 *convert = CONVERT_CK_5551;
1601                 *format = GL_BGRA;
1602                 *internal = GL_RGBA;
1603                 *type = GL_UNSIGNED_SHORT_1_5_5_5_REV;
1604             }
1605             break;
1606
1607         case WINED3DFMT_R8G8B8:
1608             if (colorkey_active) {
1609                 *convert = CONVERT_CK_RGB24;
1610                 *format = GL_RGBA;
1611                 *internal = GL_RGBA;
1612                 *type = GL_UNSIGNED_INT_8_8_8_8;
1613                 *target_bpp = 4;
1614             }
1615             break;
1616
1617         case WINED3DFMT_X8R8G8B8:
1618             if (colorkey_active) {
1619                 *convert = CONVERT_RGB32_888;
1620                 *format = GL_RGBA;
1621                 *internal = GL_RGBA;
1622                 *type = GL_UNSIGNED_INT_8_8_8_8;
1623             }
1624             break;
1625
1626         case WINED3DFMT_V8U8:
1627             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1628             else if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
1629                 *format = GL_DUDV_ATI;
1630                 *internal = GL_DU8DV8_ATI;
1631                 *type = GL_BYTE;
1632                 /* No conversion - Just change the gl type */
1633                 break;
1634             }
1635             *convert = CONVERT_V8U8;
1636             *format = GL_BGR;
1637             *internal = GL_RGB8;
1638             *type = GL_UNSIGNED_BYTE;
1639             *target_bpp = 3;
1640             break;
1641
1642         case WINED3DFMT_L6V5U5:
1643             *convert = CONVERT_L6V5U5;
1644             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1645                 *target_bpp = 3;
1646                 /* Use format and types from table */
1647             } else {
1648                 /* Load it into unsigned R5G6B5, swap L and V channels, and revert that in the shader */
1649                 *target_bpp = 2;
1650                 *format = GL_RGB;
1651                 *internal = GL_RGB5;
1652                 *type = GL_UNSIGNED_SHORT_5_6_5;
1653             }
1654             break;
1655
1656         case WINED3DFMT_X8L8V8U8:
1657             *convert = CONVERT_X8L8V8U8;
1658             *target_bpp = 4;
1659             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1660                 /* Use formats from gl table. It is a bit unfortunate, but the conversion
1661                  * is needed to set the X format to 255 to get 1.0 for alpha when sampling
1662                  * the texture. OpenGL can't use GL_DSDT8_MAG8_NV as internal format with
1663                  * the needed type and format parameter, so the internal format contains a
1664                  * 4th component, which is returned as alpha
1665                  */
1666             } else {
1667                 /* Not supported by GL_ATI_envmap_bumpmap */
1668                 *format = GL_BGRA;
1669                 *internal = GL_RGBA8;
1670                 *type = GL_UNSIGNED_BYTE;
1671             }
1672             break;
1673
1674         case WINED3DFMT_Q8W8V8U8:
1675             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1676             *convert = CONVERT_Q8W8V8U8;
1677             *format = GL_BGRA;
1678             *internal = GL_RGBA8;
1679             *type = GL_UNSIGNED_BYTE;
1680             *target_bpp = 4;
1681             /* Not supported by GL_ATI_envmap_bumpmap */
1682             break;
1683
1684         case WINED3DFMT_V16U16:
1685             if(GL_SUPPORT(NV_TEXTURE_SHADER3)) break;
1686             *convert = CONVERT_V16U16;
1687             *format = GL_BGR;
1688             *internal = GL_RGB16;
1689             *type = GL_SHORT;
1690             *target_bpp = 6;
1691             /* What should I do here about GL_ATI_envmap_bumpmap?
1692              * Convert it or allow data loss by loading it into a 8 bit / channel texture?
1693              */
1694             break;
1695
1696         case WINED3DFMT_A4L4:
1697             /* A4L4 exists as an internal gl format, but for some reason there is not
1698              * format+type combination to load it. Thus convert it to A8L8, then load it
1699              * with A4L4 internal, but A8L8 format+type
1700              */
1701             *convert = CONVERT_A4L4;
1702             *format = GL_LUMINANCE_ALPHA;
1703             *internal = GL_LUMINANCE4_ALPHA4;
1704             *type = GL_UNSIGNED_BYTE;
1705             *target_bpp = 2;
1706             break;
1707
1708         case WINED3DFMT_R32F:
1709             /* Can be loaded in theory with fmt=GL_RED, type=GL_FLOAT, but this fails. The reason
1710              * is that D3D expects the undefined green, blue and alpha channels to return 1.0
1711              * when sampling, but OpenGL sets green and blue to 0.0 instead. Thus we have to inject
1712              * 1.0 instead.
1713              *
1714              * The alpha channel defaults to 1.0 in opengl, so nothing has to be done about it.
1715              */
1716             *convert = CONVERT_R32F;
1717             *format = GL_RGB;
1718             *internal = GL_RGB32F_ARB;
1719             *type = GL_FLOAT;
1720             *target_bpp = 12;
1721             break;
1722
1723         case WINED3DFMT_R16F:
1724             /* Similar to R32F */
1725             *convert = CONVERT_R16F;
1726             *format = GL_RGB;
1727             *internal = GL_RGB16F_ARB;
1728             *type = GL_HALF_FLOAT_ARB;
1729             *target_bpp = 6;
1730             break;
1731
1732         default:
1733             break;
1734     }
1735
1736     return WINED3D_OK;
1737 }
1738
1739 HRESULT d3dfmt_convert_surface(BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This) {
1740     BYTE *source, *dest;
1741     TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
1742
1743     switch (convert) {
1744         case NO_CONVERSION:
1745         {
1746             memcpy(dst, src, pitch * height);
1747             break;
1748         }
1749         case CONVERT_PALETTED:
1750         case CONVERT_PALETTED_CK:
1751         {
1752             IWineD3DPaletteImpl* pal = This->palette;
1753             BYTE table[256][4];
1754             unsigned int i;
1755             unsigned int x, y;
1756
1757             if( pal == NULL) {
1758                 /* TODO: If we are a sublevel, try to get the palette from level 0 */
1759             }
1760
1761             if (pal == NULL) {
1762                 /* Still no palette? Use the device's palette */
1763                 /* Get the surface's palette */
1764                 for (i = 0; i < 256; i++) {
1765                     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
1766
1767                     table[i][0] = device->palettes[device->currentPalette][i].peRed;
1768                     table[i][1] = device->palettes[device->currentPalette][i].peGreen;
1769                     table[i][2] = device->palettes[device->currentPalette][i].peBlue;
1770                     if ((convert == CONVERT_PALETTED_CK) &&
1771                         (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1772                         (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1773                         /* We should maybe here put a more 'neutral' color than the standard bright purple
1774                           one often used by application to prevent the nice purple borders when bi-linear
1775                           filtering is on */
1776                         table[i][3] = 0x00;
1777                     } else {
1778                         table[i][3] = 0xFF;
1779                     }
1780                 }
1781             } else {
1782                 TRACE("Using surface palette %p\n", pal);
1783                 /* Get the surface's palette */
1784                 for (i = 0; i < 256; i++) {
1785                     table[i][0] = pal->palents[i].peRed;
1786                     table[i][1] = pal->palents[i].peGreen;
1787                     table[i][2] = pal->palents[i].peBlue;
1788                     if ((convert == CONVERT_PALETTED_CK) &&
1789                         (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
1790                         (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
1791                         /* We should maybe here put a more 'neutral' color than the standard bright purple
1792                           one often used by application to prevent the nice purple borders when bi-linear
1793                           filtering is on */
1794                         table[i][3] = 0x00;
1795                     } else if(pal->Flags & WINEDDPCAPS_ALPHA) {
1796                         table[i][3] = pal->palents[i].peFlags;
1797                     } else {
1798                         table[i][3] = 0xFF;
1799                     }
1800                 }
1801             }
1802
1803             for (y = 0; y < height; y++)
1804             {
1805                 source = src + pitch * y;
1806                 dest = dst + outpitch * y;
1807                 /* This is an 1 bpp format, using the width here is fine */
1808                 for (x = 0; x < width; x++) {
1809                     BYTE color = *source++;
1810                     *dest++ = table[color][0];
1811                     *dest++ = table[color][1];
1812                     *dest++ = table[color][2];
1813                     *dest++ = table[color][3];
1814                 }
1815             }
1816         }
1817         break;
1818
1819         case CONVERT_CK_565:
1820         {
1821             /* Converting the 565 format in 5551 packed to emulate color-keying.
1822
1823               Note : in all these conversion, it would be best to average the averaging
1824                       pixels to get the color of the pixel that will be color-keyed to
1825                       prevent 'color bleeding'. This will be done later on if ever it is
1826                       too visible.
1827
1828               Note2: Nvidia documents say that their driver does not support alpha + color keying
1829                      on the same surface and disables color keying in such a case
1830             */
1831             unsigned int x, y;
1832             WORD *Source;
1833             WORD *Dest;
1834
1835             TRACE("Color keyed 565\n");
1836
1837             for (y = 0; y < height; y++) {
1838                 Source = (WORD *) (src + y * pitch);
1839                 Dest = (WORD *) (dst + y * outpitch);
1840                 for (x = 0; x < width; x++ ) {
1841                     WORD color = *Source++;
1842                     *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
1843                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1844                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1845                         *Dest |= 0x0001;
1846                     }
1847                     Dest++;
1848                 }
1849             }
1850         }
1851         break;
1852
1853         case CONVERT_CK_5551:
1854         {
1855             /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
1856             unsigned int x, y;
1857             WORD *Source;
1858             WORD *Dest;
1859             TRACE("Color keyed 5551\n");
1860             for (y = 0; y < height; y++) {
1861                 Source = (WORD *) (src + y * pitch);
1862                 Dest = (WORD *) (dst + y * outpitch);
1863                 for (x = 0; x < width; x++ ) {
1864                     WORD color = *Source++;
1865                     *Dest = color;
1866                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
1867                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
1868                         *Dest |= (1 << 15);
1869                     }
1870                     else {
1871                         *Dest &= ~(1 << 15);
1872                     }
1873                     Dest++;
1874                 }
1875             }
1876         }
1877         break;
1878
1879         case CONVERT_V8U8:
1880         {
1881             unsigned int x, y;
1882             short *Source;
1883             unsigned char *Dest;
1884             for(y = 0; y < height; y++) {
1885                 Source = (short *) (src + y * pitch);
1886                 Dest = (unsigned char *) (dst + y * outpitch);
1887                 for (x = 0; x < width; x++ ) {
1888                     long color = (*Source++);
1889                     /* B */ Dest[0] = 0xff;
1890                     /* G */ Dest[1] = (color >> 8) + 128; /* V */
1891                     /* R */ Dest[2] = (color) + 128;      /* U */
1892                     Dest += 3;
1893                 }
1894             }
1895             break;
1896         }
1897
1898         case CONVERT_Q8W8V8U8:
1899         {
1900             unsigned int x, y;
1901             DWORD *Source;
1902             unsigned char *Dest;
1903             for(y = 0; y < height; y++) {
1904                 Source = (DWORD *) (src + y * pitch);
1905                 Dest = (unsigned char *) (dst + y * outpitch);
1906                 for (x = 0; x < width; x++ ) {
1907                     long color = (*Source++);
1908                     /* B */ Dest[0] = ((color >> 16) & 0xff) + 128; /* W */
1909                     /* G */ Dest[1] = ((color >> 8 ) & 0xff) + 128; /* V */
1910                     /* R */ Dest[2] = (color         & 0xff) + 128; /* U */
1911                     /* A */ Dest[3] = ((color >> 24) & 0xff) + 128; /* Q */
1912                     Dest += 4;
1913                 }
1914             }
1915             break;
1916         }
1917
1918         case CONVERT_L6V5U5:
1919         {
1920             unsigned int x, y;
1921             WORD *Source;
1922             unsigned char *Dest;
1923
1924             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1925                 /* This makes the gl surface bigger(24 bit instead of 16), but it works with
1926                  * fixed function and shaders without further conversion once the surface is
1927                  * loaded
1928                  */
1929                 for(y = 0; y < height; y++) {
1930                     Source = (WORD *) (src + y * pitch);
1931                     Dest = (unsigned char *) (dst + y * outpitch);
1932                     for (x = 0; x < width; x++ ) {
1933                         short color = (*Source++);
1934                         unsigned char l = ((color >> 10) & 0xfc);
1935                                   char v = ((color >>  5) & 0x3e);
1936                                   char u = ((color      ) & 0x1f);
1937
1938                         /* 8 bits destination, 6 bits source, 8th bit is the sign. gl ignores the sign
1939                          * and doubles the positive range. Thus shift left only once, gl does the 2nd
1940                          * shift. GL reads a signed value and converts it into an unsigned value.
1941                          */
1942                         /* M */ Dest[2] = l << 1;
1943
1944                         /* Those are read as signed, but kept signed. Just left-shift 3 times to scale
1945                          * from 5 bit values to 8 bit values.
1946                          */
1947                         /* V */ Dest[1] = v << 3;
1948                         /* U */ Dest[0] = u << 3;
1949                         Dest += 3;
1950                     }
1951                 }
1952             } else {
1953                 FIXME("Add D3DFMT_L6V5U5 emulation using standard unsigned RGB and shaders\n");
1954             }
1955             break;
1956         }
1957
1958         case CONVERT_X8L8V8U8:
1959         {
1960             unsigned int x, y;
1961             DWORD *Source;
1962             unsigned char *Dest;
1963
1964             if(GL_SUPPORT(NV_TEXTURE_SHADER)) {
1965                 /* This implementation works with the fixed function pipeline and shaders
1966                  * without further modification after converting the surface.
1967                  */
1968                 for(y = 0; y < height; y++) {
1969                     Source = (DWORD *) (src + y * pitch);
1970                     Dest = (unsigned char *) (dst + y * outpitch);
1971                     for (x = 0; x < width; x++ ) {
1972                         long color = (*Source++);
1973                         /* L */ Dest[2] = ((color >> 16) & 0xff);   /* L */
1974                         /* V */ Dest[1] = ((color >> 8 ) & 0xff);   /* V */
1975                         /* U */ Dest[0] = (color         & 0xff);   /* U */
1976                         /* I */ Dest[3] = 255;                      /* X */
1977                         Dest += 4;
1978                     }
1979                 }
1980             } else {
1981                 /* Doesn't work correctly with the fixed function pipeline, but can work in
1982                  * shaders if the shader is adjusted. (There's no use for this format in gl's
1983                  * standard fixed function pipeline anyway).
1984                  */
1985                 FIXME("Implement CONVERT_X8L8V8U8 with standard unsigned GL_RGB\n");
1986             }
1987             break;
1988         }
1989
1990         case CONVERT_A4L4:
1991         {
1992             unsigned int x, y;
1993             unsigned char *Source;
1994             unsigned char *Dest;
1995             for(y = 0; y < height; y++) {
1996                 Source = (unsigned char *) (src + y * pitch);
1997                 Dest = (unsigned char *) (dst + y * outpitch);
1998                 for (x = 0; x < width; x++ ) {
1999                     unsigned char color = (*Source++);
2000                     /* A */ Dest[1] = (color & 0xf0) << 0;
2001                     /* L */ Dest[0] = (color & 0x0f) << 4;
2002                     Dest += 2;
2003                 }
2004             }
2005             break;
2006         }
2007
2008         case CONVERT_R32F:
2009         {
2010             unsigned int x, y;
2011             float *Source;
2012             float *Dest;
2013             for(y = 0; y < height; y++) {
2014                 Source = (float *) (src + y * pitch);
2015                 Dest = (float *) (dst + y * outpitch);
2016                 for (x = 0; x < width; x++ ) {
2017                     float color = (*Source++);
2018                     Dest[0] = color;
2019                     Dest[1] = 1.0;
2020                     Dest[2] = 1.0;
2021                     Dest += 3;
2022                 }
2023             }
2024             break;
2025         }
2026
2027         case CONVERT_R16F:
2028         {
2029             unsigned int x, y;
2030             WORD *Source;
2031             WORD *Dest;
2032             WORD one = 0x3c00;
2033             for(y = 0; y < height; y++) {
2034                 Source = (WORD *) (src + y * pitch);
2035                 Dest = (WORD *) (dst + y * outpitch);
2036                 for (x = 0; x < width; x++ ) {
2037                     WORD color = (*Source++);
2038                     Dest[0] = color;
2039                     Dest[1] = one;
2040                     Dest[2] = one;
2041                     Dest += 3;
2042                 }
2043             }
2044             break;
2045         }
2046         default:
2047             ERR("Unsupported conversation type %d\n", convert);
2048     }
2049     return WINED3D_OK;
2050 }
2051
2052 /* This function is used in case of 8bit paletted textures to upload the palette.
2053    For now it only supports GL_EXT_paletted_texture extension but support for other
2054    extensions like ARB_fragment_program and ATI_fragment_shaders will be added as well.
2055 */
2056 static void d3dfmt_p8_upload_palette(IWineD3DSurface *iface, CONVERT_TYPES convert) {
2057     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2058     IWineD3DPaletteImpl* pal = This->palette;
2059     BYTE table[256][4];
2060     int i;
2061
2062     if (pal == NULL) {
2063         /* Still no palette? Use the device's palette */
2064         /* Get the surface's palette */
2065         for (i = 0; i < 256; i++) {
2066             IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2067
2068             table[i][0] = device->palettes[device->currentPalette][i].peRed;
2069             table[i][1] = device->palettes[device->currentPalette][i].peGreen;
2070             table[i][2] = device->palettes[device->currentPalette][i].peBlue;
2071             if ((convert == CONVERT_PALETTED_CK) &&
2072                 (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
2073                 (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
2074                 /* We should maybe here put a more 'neutral' color than the standard bright purple
2075                    one often used by application to prevent the nice purple borders when bi-linear
2076                    filtering is on */
2077                 table[i][3] = 0x00;
2078             } else {
2079                 table[i][3] = 0xFF;
2080             }
2081         }
2082     } else {
2083         TRACE("Using surface palette %p\n", pal);
2084         /* Get the surface's palette */
2085         for (i = 0; i < 256; i++) {
2086             table[i][0] = pal->palents[i].peRed;
2087             table[i][1] = pal->palents[i].peGreen;
2088             table[i][2] = pal->palents[i].peBlue;
2089             if ((convert == CONVERT_PALETTED_CK) &&
2090                 (i >= This->SrcBltCKey.dwColorSpaceLowValue) &&
2091                 (i <= This->SrcBltCKey.dwColorSpaceHighValue)) {
2092                 /* We should maybe here put a more 'neutral' color than the standard bright purple
2093                    one often used by application to prevent the nice purple borders when bi-linear
2094                    filtering is on */
2095                 table[i][3] = 0x00;
2096             } else if(pal->Flags & WINEDDPCAPS_ALPHA) {
2097                 table[i][3] = pal->palents[i].peFlags;
2098             } else {
2099                 table[i][3] = 0xFF;
2100             }
2101         }
2102     }
2103     GL_EXTCALL(glColorTableEXT(GL_TEXTURE_2D,GL_RGBA,256,GL_RGBA,GL_UNSIGNED_BYTE, table));
2104 }
2105
2106 static BOOL palette9_changed(IWineD3DSurfaceImpl *This) {
2107     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2108
2109     if(This->palette || (This->resource.format != WINED3DFMT_P8 && This->resource.format != WINED3DFMT_A8P8)) {
2110         /* If a ddraw-style palette is attached assume no d3d9 palette change.
2111          * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2112          */
2113         return FALSE;
2114     }
2115
2116     if(This->palette9) {
2117         if(memcmp(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256) == 0) {
2118             return FALSE;
2119         }
2120     } else {
2121         This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2122     }
2123     memcpy(This->palette9, &device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
2124     return TRUE;
2125 }
2126
2127 static inline void clear_unused_channels(IWineD3DSurfaceImpl *This) {
2128     GLboolean oldwrite[4];
2129
2130     /* Some formats have only some color channels, and the others are 1.0.
2131      * since our rendering renders to all channels, and those pixel formats
2132      * are emulated by using a full texture with the other channels set to 1.0
2133      * manually, clear the unused channels.
2134      *
2135      * This could be done with hacking colorwriteenable to mask the colors,
2136      * but before drawing the buffer would have to be cleared too, so there's
2137      * no gain in that
2138      */
2139     switch(This->resource.format) {
2140         case WINED3DFMT_R16F:
2141         case WINED3DFMT_R32F:
2142             TRACE("R16F or R32F format, clearing green, blue and alpha to 1.0\n");
2143             /* Do not activate a context, the correct drawable is active already
2144              * though just the read buffer is set, make sure to have the correct draw
2145              * buffer too
2146              */
2147             glDrawBuffer(This->resource.wineD3DDevice->offscreenBuffer);
2148             glDisable(GL_SCISSOR_TEST);
2149             glGetBooleanv(GL_COLOR_WRITEMASK, oldwrite);
2150             glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE);
2151             glClearColor(0.0, 1.0, 1.0, 1.0);
2152             glClear(GL_COLOR_BUFFER_BIT);
2153             glColorMask(oldwrite[0], oldwrite[1], oldwrite[2], oldwrite[3]);
2154             if(!This->resource.wineD3DDevice->render_offscreen) glDrawBuffer(GL_BACK);
2155             checkGLcall("Unused channel clear\n");
2156             break;
2157
2158         default: break;
2159     }
2160 }
2161
2162 static HRESULT WINAPI IWineD3DSurfaceImpl_LoadTexture(IWineD3DSurface *iface, BOOL srgb_mode) {
2163     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2164     IWineD3DDeviceImpl *device = This->resource.wineD3DDevice;
2165     GLenum format, internal, type;
2166     CONVERT_TYPES convert;
2167     int bpp;
2168     int width, pitch, outpitch;
2169     BYTE *mem;
2170
2171     if (!(This->Flags & SFLAG_INTEXTURE)) {
2172         TRACE("Reloading because surface is dirty\n");
2173     } else if(/* Reload: gl texture has ck, now no ckey is set OR */
2174               ((This->Flags & SFLAG_GLCKEY) && (!(This->CKeyFlags & WINEDDSD_CKSRCBLT))) ||
2175               /* Reload: vice versa  OR */
2176               ((!(This->Flags & SFLAG_GLCKEY)) && (This->CKeyFlags & WINEDDSD_CKSRCBLT)) ||
2177               /* Also reload: Color key is active AND the color key has changed */
2178               ((This->CKeyFlags & WINEDDSD_CKSRCBLT) && (
2179                 (This->glCKey.dwColorSpaceLowValue != This->SrcBltCKey.dwColorSpaceLowValue) ||
2180                 (This->glCKey.dwColorSpaceHighValue != This->SrcBltCKey.dwColorSpaceHighValue)))) {
2181         TRACE("Reloading because of color keying\n");
2182     } else if(palette9_changed(This)) {
2183         TRACE("Reloading surface because the d3d8/9 palette was changed\n");
2184     } else {
2185         TRACE("surface is already in texture\n");
2186         return WINED3D_OK;
2187     }
2188
2189     This->Flags |= SFLAG_INTEXTURE;
2190
2191     /* Resources are placed in system RAM and do not need to be recreated when a device is lost.
2192     *  These resources are not bound by device size or format restrictions. Because of this,
2193     *  these resources cannot be accessed by the Direct3D device nor set as textures or render targets.
2194     *  However, these resources can always be created, locked, and copied.
2195     */
2196     if (This->resource.pool == WINED3DPOOL_SCRATCH )
2197     {
2198         FIXME("(%p) Operation not supported for scratch textures\n",This);
2199         return WINED3DERR_INVALIDCALL;
2200     }
2201
2202     d3dfmt_get_conv(This, TRUE /* We need color keying */, TRUE /* We will use textures */, &format, &internal, &type, &convert, &bpp, srgb_mode);
2203
2204     if (This->Flags & SFLAG_INDRAWABLE) {
2205         if (This->resource.format == WINED3DFMT_P8 || This->resource.format == WINED3DFMT_A8P8 ||
2206                  This->resource.format == WINED3DFMT_DXT1 || This->resource.format == WINED3DFMT_DXT2 ||
2207                  This->resource.format == WINED3DFMT_DXT3 || This->resource.format == WINED3DFMT_DXT4 ||
2208                  This->resource.format == WINED3DFMT_DXT5)
2209             FIXME("Format %d not supported\n", This->resource.format);
2210         else {
2211             GLint prevRead;
2212
2213             ENTER_GL();
2214             glGetIntegerv(GL_READ_BUFFER, &prevRead);
2215             vcheckGLcall("glGetIntegerv");
2216             glReadBuffer(This->resource.wineD3DDevice->offscreenBuffer);
2217             vcheckGLcall("glReadBuffer");
2218
2219             if(!(This->Flags & SFLAG_ALLOCATED)) {
2220                 surface_allocate_surface(This, internal, This->pow2Width,
2221                                          This->pow2Height, format, type);
2222             }
2223
2224             clear_unused_channels(This);
2225
2226             glCopyTexSubImage2D(This->glDescription.target,
2227                                 This->glDescription.level,
2228                                 0, 0, 0, 0,
2229                                 This->currentDesc.Width,
2230                                 This->currentDesc.Height);
2231             checkGLcall("glCopyTexSubImage2D");
2232
2233             glReadBuffer(prevRead);
2234             vcheckGLcall("glReadBuffer");
2235
2236             LEAVE_GL();
2237
2238             TRACE("Updated target %d\n", This->glDescription.target);
2239         }
2240         return WINED3D_OK;
2241     } else
2242         /* The only place where LoadTexture() might get called when isInDraw=1
2243          * is ActivateContext where lastActiveRenderTarget is preloaded.
2244          */
2245         if(iface == device->lastActiveRenderTarget && device->isInDraw)
2246             ERR("Reading back render target but SFLAG_INDRAWABLE not set\n");
2247
2248     /* Otherwise: System memory copy must be most up to date */
2249
2250     if(This->CKeyFlags & WINEDDSD_CKSRCBLT) {
2251         This->Flags |= SFLAG_GLCKEY;
2252         This->glCKey = This->SrcBltCKey;
2253     }
2254     else This->Flags &= ~SFLAG_GLCKEY;
2255
2256     /* The width is in 'length' not in bytes */
2257     width = This->currentDesc.Width;
2258     pitch = IWineD3DSurface_GetPitch(iface);
2259
2260     if((convert != NO_CONVERSION) && This->resource.allocatedMemory) {
2261         int height = This->currentDesc.Height;
2262
2263         /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
2264         outpitch = width * bpp;
2265         outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
2266
2267         mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
2268         if(!mem) {
2269             ERR("Out of memory %d, %d!\n", outpitch, height);
2270             return WINED3DERR_OUTOFVIDEOMEMORY;
2271         }
2272         d3dfmt_convert_surface(This->resource.allocatedMemory, mem, pitch, width, height, outpitch, convert, This);
2273
2274         This->Flags |= SFLAG_CONVERTED;
2275     } else if (This->resource.format == WINED3DFMT_P8 && GL_SUPPORT(EXT_PALETTED_TEXTURE)) {
2276         d3dfmt_p8_upload_palette(iface, convert);
2277         This->Flags &= ~SFLAG_CONVERTED;
2278         mem = This->resource.allocatedMemory;
2279     } else {
2280         This->Flags &= ~SFLAG_CONVERTED;
2281         mem = This->resource.allocatedMemory;
2282     }
2283
2284     /* Make sure the correct pitch is used */
2285     glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
2286
2287     if ((This->Flags & SFLAG_NONPOW2) && !(This->Flags & SFLAG_OVERSIZE)) {
2288         TRACE("non power of two support\n");
2289         if(!(This->Flags & SFLAG_ALLOCATED)) {
2290             surface_allocate_surface(This, internal, This->pow2Width, This->pow2Height, format, type);
2291         }
2292         if (mem || (This->Flags & SFLAG_PBO)) {
2293             surface_upload_data(This, internal, This->currentDesc.Width, This->currentDesc.Height, format, type, mem);
2294         }
2295     } else {
2296         /* When making the realloc conditional, keep in mind that GL_APPLE_client_storage may be in use, and This->resource.allocatedMemory
2297          * changed. So also keep track of memory changes. In this case the texture has to be reallocated
2298          */
2299         if(!(This->Flags & SFLAG_ALLOCATED)) {
2300             surface_allocate_surface(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type);
2301         }
2302         if (mem || (This->Flags & SFLAG_PBO)) {
2303             surface_upload_data(This, internal, This->glRect.right - This->glRect.left, This->glRect.bottom - This->glRect.top, format, type, mem);
2304         }
2305     }
2306
2307     /* Restore the default pitch */
2308     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2309
2310     /* Don't delete PBO memory */
2311     if((mem != This->resource.allocatedMemory) && !(This->Flags & SFLAG_PBO))
2312         HeapFree(GetProcessHeap(), 0, mem);
2313
2314 #if 0
2315     {
2316         static unsigned int gen = 0;
2317         char buffer[4096];
2318         ++gen;
2319         if ((gen % 10) == 0) {
2320             snprintf(buffer, sizeof(buffer), "/tmp/surface%p_type%u_level%u_%u.ppm", This, This->glDescription.target, This->glDescription.level, gen);
2321             IWineD3DSurfaceImpl_SaveSnapshot(iface, buffer);
2322         }
2323         /*
2324          * debugging crash code
2325          if (gen == 250) {
2326          void** test = NULL;
2327          *test = 0;
2328          }
2329          */
2330     }
2331 #endif
2332
2333     if (!(This->Flags & SFLAG_DONOTFREE)) {
2334         HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
2335         This->resource.allocatedMemory = NULL;
2336         This->Flags &= ~SFLAG_INSYSMEM;
2337     }
2338
2339     return WINED3D_OK;
2340 }
2341
2342 #include <errno.h>
2343 #include <stdio.h>
2344 HRESULT WINAPI IWineD3DSurfaceImpl_SaveSnapshot(IWineD3DSurface *iface, const char* filename) {
2345     FILE* f = NULL;
2346     UINT i, y;
2347     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2348     char *allocatedMemory;
2349     char *textureRow;
2350     IWineD3DSwapChain *swapChain = NULL;
2351     int width, height;
2352     GLuint tmpTexture = 0;
2353     DWORD color;
2354     /*FIXME:
2355     Textures may not be stored in ->allocatedgMemory and a GlTexture
2356     so we should lock the surface before saving a snapshot, or at least check that
2357     */
2358     /* TODO: Compressed texture images can be obtained from the GL in uncompressed form
2359     by calling GetTexImage and in compressed form by calling
2360     GetCompressedTexImageARB.  Queried compressed images can be saved and
2361     later reused by calling CompressedTexImage[123]DARB.  Pre-compressed
2362     texture images do not need to be processed by the GL and should
2363     significantly improve texture loading performance relative to uncompressed
2364     images. */
2365
2366 /* Setup the width and height to be the internal texture width and height. */
2367     width  = This->pow2Width;
2368     height = This->pow2Height;
2369 /* check to see if we're a 'virtual' texture, e.g. we're not a pbuffer of texture, we're a back buffer*/
2370     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **)&swapChain);
2371
2372     if (This->Flags & SFLAG_INDRAWABLE && !(This->Flags & SFLAG_INTEXTURE)) {
2373         /* if were not a real texture then read the back buffer into a real texture */
2374         /* we don't want to interfere with the back buffer so read the data into a temporary
2375          * texture and then save the data out of the temporary texture
2376          */
2377         GLint prevRead;
2378         ENTER_GL();
2379         TRACE("(%p) Reading render target into texture\n", This);
2380         glEnable(GL_TEXTURE_2D);
2381
2382         glGenTextures(1, &tmpTexture);
2383         glBindTexture(GL_TEXTURE_2D, tmpTexture);
2384
2385         glTexImage2D(GL_TEXTURE_2D,
2386                         0,
2387                         GL_RGBA,
2388                         width,
2389                         height,
2390                         0/*border*/,
2391                         GL_RGBA,
2392                         GL_UNSIGNED_INT_8_8_8_8_REV,
2393                         NULL);
2394
2395         glGetIntegerv(GL_READ_BUFFER, &prevRead);
2396         vcheckGLcall("glGetIntegerv");
2397         glReadBuffer(swapChain ? GL_BACK : This->resource.wineD3DDevice->offscreenBuffer);
2398         vcheckGLcall("glReadBuffer");
2399         glCopyTexImage2D(GL_TEXTURE_2D,
2400                             0,
2401                             GL_RGBA,
2402                             0,
2403                             0,
2404                             width,
2405                             height,
2406                             0);
2407
2408         checkGLcall("glCopyTexImage2D");
2409         glReadBuffer(prevRead);
2410         LEAVE_GL();
2411
2412     } else { /* bind the real texture, and make sure it up to date */
2413         IWineD3DSurface_PreLoad(iface);
2414     }
2415     allocatedMemory = HeapAlloc(GetProcessHeap(), 0, width  * height * 4);
2416     ENTER_GL();
2417     FIXME("Saving texture level %d width %d height %d\n", This->glDescription.level, width, height);
2418     glGetTexImage(GL_TEXTURE_2D,
2419                 This->glDescription.level,
2420                 GL_RGBA,
2421                 GL_UNSIGNED_INT_8_8_8_8_REV,
2422                 allocatedMemory);
2423     checkGLcall("glTexImage2D");
2424     if (tmpTexture) {
2425         glBindTexture(GL_TEXTURE_2D, 0);
2426         glDeleteTextures(1, &tmpTexture);
2427     }
2428     LEAVE_GL();
2429
2430     f = fopen(filename, "w+");
2431     if (NULL == f) {
2432         ERR("opening of %s failed with: %s\n", filename, strerror(errno));
2433         return WINED3DERR_INVALIDCALL;
2434     }
2435 /* Save the data out to a TGA file because 1: it's an easy raw format, 2: it supports an alpha channel */
2436     TRACE("(%p) opened %s with format %s\n", This, filename, debug_d3dformat(This->resource.format));
2437 /* TGA header */
2438     fputc(0,f);
2439     fputc(0,f);
2440     fputc(2,f);
2441     fputc(0,f);
2442     fputc(0,f);
2443     fputc(0,f);
2444     fputc(0,f);
2445     fputc(0,f);
2446     fputc(0,f);
2447     fputc(0,f);
2448     fputc(0,f);
2449     fputc(0,f);
2450 /* short width*/
2451     fwrite(&width,2,1,f);
2452 /* short height */
2453     fwrite(&height,2,1,f);
2454 /* format rgba */
2455     fputc(0x20,f);
2456     fputc(0x28,f);
2457 /* raw data */
2458     /* 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 */
2459     if(swapChain)
2460         textureRow = allocatedMemory + (width * (height - 1) *4);
2461     else
2462         textureRow = allocatedMemory;
2463     for (y = 0 ; y < height; y++) {
2464         for (i = 0; i < width;  i++) {
2465             color = *((DWORD*)textureRow);
2466             fputc((color >> 16) & 0xFF, f); /* B */
2467             fputc((color >>  8) & 0xFF, f); /* G */
2468             fputc((color >>  0) & 0xFF, f); /* R */
2469             fputc((color >> 24) & 0xFF, f); /* A */
2470             textureRow += 4;
2471         }
2472         /* take two rows of the pointer to the texture memory */
2473         if(swapChain)
2474             (textureRow-= width << 3);
2475
2476     }
2477     TRACE("Closing file\n");
2478     fclose(f);
2479
2480     if(swapChain) {
2481         IWineD3DSwapChain_Release(swapChain);
2482     }
2483     HeapFree(GetProcessHeap(), 0, allocatedMemory);
2484     return WINED3D_OK;
2485 }
2486
2487 /**
2488  *   Slightly inefficient way to handle multiple dirty rects but it works :)
2489  */
2490 extern HRESULT WINAPI IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface *iface, CONST RECT* pDirtyRect) {
2491     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2492     IWineD3DBaseTexture *baseTexture = NULL;
2493     if (!(This->Flags & SFLAG_INSYSMEM) && (This->Flags & SFLAG_INTEXTURE))
2494         surface_download_data(This);
2495
2496     This->Flags &= ~(SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
2497     if (NULL != pDirtyRect) {
2498         This->dirtyRect.left   = min(This->dirtyRect.left,   pDirtyRect->left);
2499         This->dirtyRect.top    = min(This->dirtyRect.top,    pDirtyRect->top);
2500         This->dirtyRect.right  = max(This->dirtyRect.right,  pDirtyRect->right);
2501         This->dirtyRect.bottom = max(This->dirtyRect.bottom, pDirtyRect->bottom);
2502     } else {
2503         This->dirtyRect.left   = 0;
2504         This->dirtyRect.top    = 0;
2505         This->dirtyRect.right  = This->currentDesc.Width;
2506         This->dirtyRect.bottom = This->currentDesc.Height;
2507     }
2508     TRACE("(%p) : Dirty: yes, Rect:(%d,%d,%d,%d)\n", This, This->dirtyRect.left,
2509           This->dirtyRect.top, This->dirtyRect.right, This->dirtyRect.bottom);
2510     /* if the container is a basetexture then mark it dirty. */
2511     if (IWineD3DSurface_GetContainer(iface, &IID_IWineD3DBaseTexture, (void **)&baseTexture) == WINED3D_OK) {
2512         TRACE("Passing to container\n");
2513         IWineD3DBaseTexture_SetDirty(baseTexture, TRUE);
2514         IWineD3DBaseTexture_Release(baseTexture);
2515     }
2516     return WINED3D_OK;
2517 }
2518
2519 HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format) {
2520     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2521     HRESULT hr;
2522     const GlPixelFormatDesc *glDesc;
2523     getFormatDescEntry(format, &GLINFO_LOCATION, &glDesc);
2524
2525     TRACE("(%p) : Calling base function first\n", This);
2526     hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2527     if(SUCCEEDED(hr)) {
2528         /* Setup some glformat defaults */
2529         This->glDescription.glFormat         = glDesc->glFormat;
2530         This->glDescription.glFormatInternal = glDesc->glInternal;
2531         This->glDescription.glType           = glDesc->glType;
2532
2533         This->Flags &= ~SFLAG_ALLOCATED;
2534         TRACE("(%p) : glFormat %d, glFotmatInternal %d, glType %d\n", This,
2535               This->glDescription.glFormat, This->glDescription.glFormatInternal, This->glDescription.glType);
2536     }
2537     return hr;
2538 }
2539
2540 HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2541     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2542
2543     if(This->Flags & (SFLAG_LOCKED | SFLAG_DCINUSE)) {
2544         WARN("Surface is locked or the HDC is in use\n");
2545         return WINED3DERR_INVALIDCALL;
2546     }
2547
2548     if(Mem && Mem != This->resource.allocatedMemory) {
2549         void *release = NULL;
2550
2551         /* Do I have to copy the old surface content? */
2552         if(This->Flags & SFLAG_DIBSECTION) {
2553                 /* Release the DC. No need to hold the critical section for the update
2554                  * Thread because this thread runs only on front buffers, but this method
2555                  * fails for render targets in the check above.
2556                  */
2557                 SelectObject(This->hDC, This->dib.holdbitmap);
2558                 DeleteDC(This->hDC);
2559                 /* Release the DIB section */
2560                 DeleteObject(This->dib.DIBsection);
2561                 This->dib.bitmap_data = NULL;
2562                 This->resource.allocatedMemory = NULL;
2563                 This->hDC = NULL;
2564                 This->Flags &= ~SFLAG_DIBSECTION;
2565         } else if(!(This->Flags & SFLAG_USERPTR)) {
2566             release = This->resource.allocatedMemory;
2567         }
2568         This->resource.allocatedMemory = Mem;
2569         This->Flags |= SFLAG_USERPTR | SFLAG_INSYSMEM;
2570
2571         /* Now the surface memory is most up do date. Invalidate drawable and texture */
2572         This->Flags &= ~(SFLAG_INDRAWABLE | SFLAG_INTEXTURE);
2573
2574         /* For client textures opengl has to be notified */
2575         if(This->Flags & SFLAG_CLIENT) {
2576             This->Flags &= ~SFLAG_ALLOCATED;
2577             IWineD3DSurface_PreLoad(iface);
2578             /* And hope that the app behaves correctly and did not free the old surface memory before setting a new pointer */
2579         }
2580
2581         /* Now free the old memory if any */
2582         HeapFree(GetProcessHeap(), 0, release);
2583     } else if(This->Flags & SFLAG_USERPTR) {
2584         /* Lockrect and GetDC will re-create the dib section and allocated memory */
2585         This->resource.allocatedMemory = NULL;
2586         This->Flags &= ~SFLAG_USERPTR;
2587
2588         if(This->Flags & SFLAG_CLIENT) {
2589             This->Flags &= ~SFLAG_ALLOCATED;
2590             /* This respecifies an empty texture and opengl knows that the old memory is gone */
2591             IWineD3DSurface_PreLoad(iface);
2592         }
2593     }
2594     return WINED3D_OK;
2595 }
2596
2597 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD Flags) {
2598     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2599     IWineD3DSwapChainImpl *swapchain = NULL;
2600     HRESULT hr;
2601     TRACE("(%p)->(%p,%x)\n", This, override, Flags);
2602
2603     /* Flipping is only supported on RenderTargets */
2604     if( !(This->resource.usage & WINED3DUSAGE_RENDERTARGET) ) return WINEDDERR_NOTFLIPPABLE;
2605
2606     if(override) {
2607         /* DDraw sets this for the X11 surfaces, so don't confuse the user
2608          * FIXME("(%p) Target override is not supported by now\n", This);
2609          * Additionally, it isn't really possible to support triple-buffering
2610          * properly on opengl at all
2611          */
2612     }
2613
2614     IWineD3DSurface_GetContainer(iface, &IID_IWineD3DSwapChain, (void **) &swapchain);
2615     if(!swapchain) {
2616         ERR("Flipped surface is not on a swapchain\n");
2617         return WINEDDERR_NOTFLIPPABLE;
2618     }
2619
2620     /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2621      * and only d3d8 and d3d9 apps specify the presentation interval
2622      */
2623     if((Flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)) == 0) {
2624         /* Most common case first to avoid wasting time on all the other cases */
2625         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
2626     } else if(Flags & WINEDDFLIP_NOVSYNC) {
2627         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2628     } else if(Flags & WINEDDFLIP_INTERVAL2) {
2629         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
2630     } else if(Flags & WINEDDFLIP_INTERVAL3) {
2631         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
2632     } else {
2633         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
2634     }
2635
2636     /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2637     hr = IWineD3DSwapChain_Present((IWineD3DSwapChain *) swapchain, NULL, NULL, 0, NULL, 0);
2638     IWineD3DSwapChain_Release((IWineD3DSwapChain *) swapchain);
2639     return hr;
2640 }
2641
2642 /* Does a direct frame buffer -> texture copy. Stretching is done
2643  * with single pixel copy calls
2644  */
2645 static inline void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface, IWineD3DSwapChainImpl *swapchain, WINED3DRECT *srect, WINED3DRECT *drect, BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter) {
2646     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2647     float xrel, yrel;
2648     UINT row;
2649     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2650
2651
2652     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2653     ENTER_GL();
2654     IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
2655
2656     /* Bind the target texture */
2657     glBindTexture(GL_TEXTURE_2D, This->glDescription.textureName);
2658     checkGLcall("glBindTexture");
2659     if(!swapchain) {
2660         glReadBuffer(myDevice->offscreenBuffer);
2661     } else {
2662         GLenum buffer = surface_get_gl_buffer(SrcSurface, (IWineD3DSwapChain *)swapchain);
2663         glReadBuffer(buffer);
2664     }
2665     checkGLcall("glReadBuffer");
2666
2667     xrel = (float) (srect->x2 - srect->x1) / (float) (drect->x2 - drect->x1);
2668     yrel = (float) (srect->y2 - srect->y1) / (float) (drect->y2 - drect->y1);
2669
2670     if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2671         FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2672
2673         if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
2674             ERR("Texture filtering not supported in direct blit\n");
2675         }
2676     } else if((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) && ((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2677         ERR("Texture filtering not supported in direct blit\n");
2678     }
2679
2680     if(upsidedown &&
2681        !((xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) &&
2682        !((yrel - 1.0 < -eps) || (yrel - 1.0 > eps))) {
2683         /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2684
2685         glCopyTexSubImage2D(This->glDescription.target,
2686                             This->glDescription.level,
2687                             drect->x1, drect->y1, /* xoffset, yoffset */
2688                             srect->x1, Src->currentDesc.Height - srect->y2,
2689                             drect->x2 - drect->x1, drect->y2 - drect->y1);
2690     } else {
2691         UINT yoffset = Src->currentDesc.Height - srect->y1 + drect->y1 - 1;
2692         /* I have to process this row by row to swap the image,
2693          * otherwise it would be upside down, so stretching in y direction
2694          * doesn't cost extra time
2695          *
2696          * However, stretching in x direction can be avoided if not necessary
2697          */
2698         for(row = drect->y1; row < drect->y2; row++) {
2699             if( (xrel - 1.0 < -eps) || (xrel - 1.0 > eps)) {
2700                 /* Well, that stuff works, but it's very slow.
2701                  * find a better way instead
2702                  */
2703                 UINT col;
2704
2705                 for(col = drect->x1; col < drect->x2; col++) {
2706                     glCopyTexSubImage2D(This->glDescription.target,
2707                                         This->glDescription.level,
2708                                         drect->x1 + col, row, /* xoffset, yoffset */
2709                                         srect->x1 + col * xrel, yoffset - (int) (row * yrel),
2710                                         1, 1);
2711                 }
2712             } else {
2713                 glCopyTexSubImage2D(This->glDescription.target,
2714                                     This->glDescription.level,
2715                                     drect->x1, row, /* xoffset, yoffset */
2716                                     srect->x1, yoffset - (int) (row * yrel),
2717                                     drect->x2-drect->x1, 1);
2718             }
2719         }
2720     }
2721
2722     vcheckGLcall("glCopyTexSubImage2D");
2723     LEAVE_GL();
2724 }
2725
2726 /* Uses the hardware to stretch and flip the image */
2727 static inline void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *This, IWineD3DSurface *SrcSurface, IWineD3DSwapChainImpl *swapchain, WINED3DRECT *srect, WINED3DRECT *drect, BOOL upsidedown, WINED3DTEXTUREFILTERTYPE Filter) {
2728     GLuint src, backup = 0;
2729     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2730     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2731     float left, right, top, bottom; /* Texture coordinates */
2732     UINT fbwidth = Src->currentDesc.Width;
2733     UINT fbheight = Src->currentDesc.Height;
2734     GLenum drawBuffer = GL_BACK;
2735
2736     TRACE("Using hwstretch blit\n");
2737     /* Activate the Proper context for reading from the source surface, set it up for blitting */
2738     ActivateContext(myDevice, SrcSurface, CTXUSAGE_BLIT);
2739     ENTER_GL();
2740     IWineD3DSurface_PreLoad((IWineD3DSurface *) This);
2741
2742     /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
2743      * This way we don't have to wait for the 2nd readback to finish to leave this function.
2744      */
2745     if(GL_LIMITS(aux_buffers) >= 2) {
2746         /* Got more than one aux buffer? Use the 2nd aux buffer */
2747         drawBuffer = GL_AUX1;
2748     } else if((swapchain || myDevice->offscreenBuffer == GL_BACK) && GL_LIMITS(aux_buffers) >= 1) {
2749         /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
2750         drawBuffer = GL_AUX0;
2751     }
2752
2753     if(!swapchain && wined3d_settings.offscreen_rendering_mode == ORM_FBO) {
2754         glGenTextures(1, &backup);
2755         checkGLcall("glGenTextures\n");
2756         glBindTexture(GL_TEXTURE_2D, backup);
2757         checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2758     } else {
2759         /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
2760          * we are reading from the back buffer, the backup can be used as source texture
2761          */
2762         if(Src->glDescription.textureName == 0) {
2763             /* Get it a description */
2764             IWineD3DSurface_PreLoad(SrcSurface);
2765         }
2766         glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName);
2767         checkGLcall("glBindTexture(Src->glDescription.target, Src->glDescription.textureName)");
2768
2769         /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
2770         Src->Flags &= ~SFLAG_INTEXTURE;
2771     }
2772
2773     glReadBuffer(GL_BACK);
2774     checkGLcall("glReadBuffer(GL_BACK)");
2775
2776     /* TODO: Only back up the part that will be overwritten */
2777     glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
2778                         0, 0 /* read offsets */,
2779                         0, 0,
2780                         fbwidth,
2781                         fbheight);
2782
2783     checkGLcall("glCopyTexSubImage2D");
2784
2785     /* No issue with overriding these - the sampler is dirty due to blit usage */
2786     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
2787                     stateLookup[WINELOOKUP_MAGFILTER][Filter - minLookup[WINELOOKUP_MAGFILTER]]);
2788     checkGLcall("glTexParameteri");
2789     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
2790                     minMipLookup[Filter][WINED3DTEXF_NONE]);
2791     checkGLcall("glTexParameteri");
2792
2793     if(!swapchain || (IWineD3DSurface *) Src == swapchain->backBuffer[0]) {
2794         src = backup ? backup : Src->glDescription.textureName;
2795     } else {
2796         glReadBuffer(GL_FRONT);
2797         checkGLcall("glReadBuffer(GL_FRONT)");
2798
2799         glGenTextures(1, &src);
2800         checkGLcall("glGenTextures(1, &src)");
2801         glBindTexture(GL_TEXTURE_2D, src);
2802         checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
2803
2804         /* TODO: Only copy the part that will be read. Use srect->x1, srect->y2 as origin, but with the width watch
2805          * out for power of 2 sizes
2806          */
2807         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, Src->pow2Width, Src->pow2Height, 0,
2808                     GL_RGBA, GL_UNSIGNED_BYTE, NULL);
2809         checkGLcall("glTexImage2D");
2810         glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
2811                             0, 0 /* read offsets */,
2812                             0, 0,
2813                             fbwidth,
2814                             fbheight);
2815
2816         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2817         checkGLcall("glTexParameteri");
2818         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2819         checkGLcall("glTexParameteri");
2820
2821         glReadBuffer(GL_BACK);
2822         checkGLcall("glReadBuffer(GL_BACK)");
2823     }
2824     checkGLcall("glEnd and previous");
2825
2826     left = (float) srect->x1 / (float) Src->pow2Width;
2827     right = (float) srect->x2 / (float) Src->pow2Width;
2828
2829     if(upsidedown) {
2830         top = (float) (Src->currentDesc.Height - srect->y1) / (float) Src->pow2Height;
2831         bottom = (float) (Src->currentDesc.Height - srect->y2) / (float) Src->pow2Height;
2832     } else {
2833         top = (float) (Src->currentDesc.Height - srect->y2) / (float) Src->pow2Height;
2834         bottom = (float) (Src->currentDesc.Height - srect->y1) / (float) Src->pow2Height;
2835     }
2836
2837     /* draw the source texture stretched and upside down. The correct surface is bound already */
2838     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
2839     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
2840
2841     glDrawBuffer(drawBuffer);
2842     glReadBuffer(drawBuffer);
2843
2844     glBegin(GL_QUADS);
2845         /* bottom left */
2846         glTexCoord2f(left, bottom);
2847         glVertex2i(0, fbheight);
2848
2849         /* top left */
2850         glTexCoord2f(left, top);
2851         glVertex2i(0, fbheight - drect->y2 - drect->y1);
2852
2853         /* top right */
2854         glTexCoord2f(right, top);
2855         glVertex2i(drect->x2 - drect->x1, fbheight - drect->y2 - drect->y1);
2856
2857         /* bottom right */
2858         glTexCoord2f(right, bottom);
2859         glVertex2i(drect->x2 - drect->x1, fbheight);
2860     glEnd();
2861     checkGLcall("glEnd and previous");
2862
2863     /* Now read the stretched and upside down image into the destination texture */
2864     glBindTexture(This->glDescription.target, This->glDescription.textureName);
2865     checkGLcall("glBindTexture");
2866     glCopyTexSubImage2D(This->glDescription.target,
2867                         0,
2868                         drect->x1, drect->y1, /* xoffset, yoffset */
2869                         0, 0, /* We blitted the image to the origin */
2870                         drect->x2 - drect->x1, drect->y2 - drect->y1);
2871     checkGLcall("glCopyTexSubImage2D");
2872
2873     /* Write the back buffer backup back */
2874     glBindTexture(GL_TEXTURE_2D, backup ? backup : Src->glDescription.textureName);
2875     checkGLcall("glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName)");
2876
2877     if(drawBuffer == GL_BACK) {
2878         glBegin(GL_QUADS);
2879             /* top left */
2880             glTexCoord2f(0.0, (float) fbheight / (float) Src->pow2Height);
2881             glVertex2i(0, 0);
2882
2883             /* bottom left */
2884             glTexCoord2f(0.0, 0.0);
2885             glVertex2i(0, fbheight);
2886
2887             /* bottom right */
2888             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, 0.0);
2889             glVertex2i(fbwidth, Src->currentDesc.Height);
2890
2891             /* top right */
2892             glTexCoord2f((float) fbwidth / (float) Src->pow2Width, (float) fbheight / (float) Src->pow2Height);
2893             glVertex2i(fbwidth, 0);
2894         glEnd();
2895     } else {
2896         /* Restore the old draw buffer */
2897         glDrawBuffer(GL_BACK);
2898     }
2899
2900     /* Cleanup */
2901     if(src != Src->glDescription.textureName && src != backup) {
2902         glDeleteTextures(1, &src);
2903         checkGLcall("glDeleteTextures(1, &src)");
2904     }
2905     if(backup) {
2906         glDeleteTextures(1, &backup);
2907         checkGLcall("glDeleteTextures(1, &backup)");
2908     }
2909     LEAVE_GL();
2910 }
2911
2912 /* Not called from the VTable */
2913 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *This, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
2914     WINED3DRECT rect;
2915     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
2916     IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
2917     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
2918
2919     TRACE("(%p)->(%p,%p,%p,%08x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
2920
2921     /* Get the swapchain. One of the surfaces has to be a primary surface */
2922     if(This->resource.pool == WINED3DPOOL_SYSTEMMEM) {
2923         WARN("Destination is in sysmem, rejecting gl blt\n");
2924         return WINED3DERR_INVALIDCALL;
2925     }
2926     IWineD3DSurface_GetContainer( (IWineD3DSurface *) This, &IID_IWineD3DSwapChain, (void **)&dstSwapchain);
2927     if(dstSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) dstSwapchain);
2928     if(Src) {
2929         if(Src->resource.pool == WINED3DPOOL_SYSTEMMEM) {
2930             WARN("Src is in sysmem, rejecting gl blt\n");
2931             return WINED3DERR_INVALIDCALL;
2932         }
2933         IWineD3DSurface_GetContainer( (IWineD3DSurface *) Src, &IID_IWineD3DSwapChain, (void **)&srcSwapchain);
2934         if(srcSwapchain) IWineD3DSwapChain_Release((IWineD3DSwapChain *) srcSwapchain);
2935     }
2936
2937     /* Early sort out of cases where no render target is used */
2938     if(!dstSwapchain && !srcSwapchain &&
2939         SrcSurface != myDevice->render_targets[0] && This != (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
2940         TRACE("No surface is render target, not using hardware blit. Src = %p, dst = %p\n", Src, This);
2941         return WINED3DERR_INVALIDCALL;
2942     }
2943
2944     /* No destination color keying supported */
2945     if(Flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE)) {
2946         /* Can we support that with glBlendFunc if blitting to the frame buffer? */
2947         TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
2948         return WINED3DERR_INVALIDCALL;
2949     }
2950
2951     if (DestRect) {
2952         rect.x1 = DestRect->left;
2953         rect.y1 = DestRect->top;
2954         rect.x2 = DestRect->right;
2955         rect.y2 = DestRect->bottom;
2956     } else {
2957         rect.x1 = 0;
2958         rect.y1 = 0;
2959         rect.x2 = This->currentDesc.Width;
2960         rect.y2 = This->currentDesc.Height;
2961     }
2962
2963     /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
2964     if(dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->backBuffer &&
2965        ((IWineD3DSurface *) This == dstSwapchain->frontBuffer) && SrcSurface == dstSwapchain->backBuffer[0]) {
2966         /* Half-life does a Blt from the back buffer to the front buffer,
2967          * Full surface size, no flags... Use present instead
2968          *
2969          * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
2970          */
2971
2972         /* Check rects - IWineD3DDevice_Present doesn't handle them */
2973         while(1)
2974         {
2975             RECT mySrcRect;
2976             TRACE("Looking if a Present can be done...\n");
2977             /* Source Rectangle must be full surface */
2978             if( SrcRect ) {
2979                 if(SrcRect->left != 0 || SrcRect->top != 0 ||
2980                    SrcRect->right != Src->currentDesc.Width || SrcRect->bottom != Src->currentDesc.Height) {
2981                     TRACE("No, Source rectangle doesn't match\n");
2982                     break;
2983                 }
2984             }
2985             mySrcRect.left = 0;
2986             mySrcRect.top = 0;
2987             mySrcRect.right = Src->currentDesc.Width;
2988             mySrcRect.bottom = Src->currentDesc.Height;
2989
2990             /* No stretching may occur */
2991             if(mySrcRect.right != rect.x2 - rect.x1 ||
2992                mySrcRect.bottom != rect.y2 - rect.y1) {
2993                 TRACE("No, stretching is done\n");
2994                 break;
2995             }
2996
2997             /* Destination must be full surface or match the clipping rectangle */
2998             if(This->clipper && ((IWineD3DClipperImpl *) This->clipper)->hWnd)
2999             {
3000                 RECT cliprect;
3001                 POINT pos[2];
3002                 GetClientRect(((IWineD3DClipperImpl *) This->clipper)->hWnd, &cliprect);
3003                 pos[0].x = rect.x1;
3004                 pos[0].y = rect.y1;
3005                 pos[1].x = rect.x2;
3006                 pos[1].y = rect.y2;
3007                 MapWindowPoints(GetDesktopWindow(), ((IWineD3DClipperImpl *) This->clipper)->hWnd,
3008                                 pos, 2);
3009
3010                 if(pos[0].x != cliprect.left  || pos[0].y != cliprect.top   ||
3011                    pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
3012                 {
3013                     TRACE("No, dest rectangle doesn't match(clipper)\n");
3014                     TRACE("Clip rect at (%d,%d)-(%d,%d)\n", cliprect.left, cliprect.top, cliprect.right, cliprect.bottom);
3015                     TRACE("Blt dest: (%d,%d)-(%d,%d)\n", rect.x1, rect.y1, rect.x2, rect.y2);
3016                     break;
3017                 }
3018             }
3019             else
3020             {
3021                 if(rect.x1 != 0 || rect.y1 != 0 ||
3022                    rect.x2 != This->currentDesc.Width || rect.y2 != This->currentDesc.Height) {
3023                     TRACE("No, dest rectangle doesn't match(surface size)\n");
3024                     break;
3025                 }
3026             }
3027
3028             TRACE("Yes\n");
3029
3030             /* These flags are unimportant for the flag check, remove them */
3031             if((Flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)) == 0) {
3032                 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
3033
3034                 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3035                     * take very long, while a flip is fast.
3036                     * This applies to Half-Life, which does such Blts every time it finished
3037                     * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3038                     * menu. This is also used by all apps when they do windowed rendering
3039                     *
3040                     * The problem is that flipping is not really the same as copying. After a
3041                     * Blt the front buffer is a copy of the back buffer, and the back buffer is
3042                     * untouched. Therefore it's necessary to override the swap effect
3043                     * and to set it back after the flip.
3044                     *
3045                     * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3046                     * testcases.
3047                     */
3048
3049                 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
3050                 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3051
3052                 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3053                 IWineD3DSwapChain_Present((IWineD3DSwapChain *) dstSwapchain, NULL, NULL, 0, NULL, 0);
3054
3055                 dstSwapchain->presentParms.SwapEffect = orig_swap;
3056
3057                 return WINED3D_OK;
3058             }
3059             break;
3060         }
3061
3062         TRACE("Unsupported blit between buffers on the same swapchain\n");
3063         return WINED3DERR_INVALIDCALL;
3064     } else if((dstSwapchain || This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) &&
3065               (srcSwapchain || SrcSurface == myDevice->render_targets[0]) ) {
3066         ERR("Can't perform hardware blit between 2 different swapchains, falling back to software\n");
3067         return WINED3DERR_INVALIDCALL;
3068     }
3069
3070     if(srcSwapchain || SrcSurface == myDevice->render_targets[0]) {
3071         /* Blit from render target to texture */
3072         WINED3DRECT srect;
3073         BOOL upsideDown, stretchx;
3074
3075         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3076             TRACE("Color keying not supported by frame buffer to texture blit\n");
3077             return WINED3DERR_INVALIDCALL;
3078             /* Destination color key is checked above */
3079         }
3080
3081         /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3082          * glCopyTexSubImage is a bit picky about the parameters we pass to it
3083          */
3084         if(SrcRect) {
3085             if(SrcRect->top < SrcRect->bottom) {
3086                 srect.y1 = SrcRect->top;
3087                 srect.y2 = SrcRect->bottom;
3088                 upsideDown = FALSE;
3089             } else {
3090                 srect.y1 = SrcRect->bottom;
3091                 srect.y2 = SrcRect->top;
3092                 upsideDown = TRUE;
3093             }
3094             srect.x1 = SrcRect->left;
3095             srect.x2 = SrcRect->right;
3096         } else {
3097             srect.x1 = 0;
3098             srect.y1 = 0;
3099             srect.x2 = Src->currentDesc.Width;
3100             srect.y2 = Src->currentDesc.Height;
3101             upsideDown = FALSE;
3102         }
3103         if(rect.x1 > rect.x2) {
3104             UINT tmp = rect.x2;
3105             rect.x2 = rect.x1;
3106             rect.x1 = tmp;
3107             upsideDown = !upsideDown;
3108         }
3109         if(!srcSwapchain) {
3110             TRACE("Reading from an offscreen target\n");
3111             upsideDown = !upsideDown;
3112         }
3113
3114         if(rect.x2 - rect.x1 != srect.x2 - srect.x1) {
3115             stretchx = TRUE;
3116         } else {
3117             stretchx = FALSE;
3118         }
3119
3120         /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3121          * flip the image nor scale it.
3122          *
3123          * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3124          * -> If the app wants a image width an unscaled width, copy it line per line
3125          * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3126          *    than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3127          *    back buffer. This is slower than reading line per line, thus not used for flipping
3128          * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3129          *    pixel by pixel
3130          *
3131          * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3132          * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3133          * backends.
3134          */
3135         if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && GL_SUPPORT(EXT_FRAMEBUFFER_BLIT)) {
3136             stretch_rect_fbo((IWineD3DDevice *)myDevice, SrcSurface, &srect,
3137                     (IWineD3DSurface *)This, &rect, Filter, upsideDown);
3138         } else if((!stretchx) || rect.x2 - rect.x1 > Src->currentDesc.Width ||
3139                                     rect.y2 - rect.y1 > Src->currentDesc.Height) {
3140             TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3141             fb_copy_to_texture_direct(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3142         } else {
3143             TRACE("Using hardware stretching to flip / stretch the texture\n");
3144             fb_copy_to_texture_hwstretch(This, SrcSurface, srcSwapchain, &srect, &rect, upsideDown, Filter);
3145         }
3146
3147         if(!(This->Flags & SFLAG_DONOTFREE)) {
3148             HeapFree(GetProcessHeap(), 0, This->resource.allocatedMemory);
3149             This->resource.allocatedMemory = NULL;
3150         } else {
3151             This->Flags &= ~SFLAG_INSYSMEM;
3152         }
3153         /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3154          * path is never entered
3155          */
3156         This->Flags |= SFLAG_INTEXTURE;
3157
3158         return WINED3D_OK;
3159     } else if(Src) {
3160         /* Blit from offscreen surface to render target */
3161         float glTexCoord[4];
3162         DWORD oldCKeyFlags = Src->CKeyFlags;
3163         WINEDDCOLORKEY oldBltCKey = This->SrcBltCKey;
3164         RECT SourceRectangle;
3165
3166         TRACE("Blt from surface %p to rendertarget %p\n", Src, This);
3167
3168         if(SrcRect) {
3169             SourceRectangle.left = SrcRect->left;
3170             SourceRectangle.right = SrcRect->right;
3171             SourceRectangle.top = SrcRect->top;
3172             SourceRectangle.bottom = SrcRect->bottom;
3173         } else {
3174             SourceRectangle.left = 0;
3175             SourceRectangle.right = Src->currentDesc.Width;
3176             SourceRectangle.top = 0;
3177             SourceRectangle.bottom = Src->currentDesc.Height;
3178         }
3179
3180         if(!CalculateTexRect(Src, &SourceRectangle, glTexCoord)) {
3181             /* Fall back to software */
3182             WARN("(%p) Source texture area (%d,%d)-(%d,%d) is too big\n", Src,
3183                     SourceRectangle.left, SourceRectangle.top,
3184                     SourceRectangle.right, SourceRectangle.bottom);
3185             return WINED3DERR_INVALIDCALL;
3186         }
3187
3188         /* Color keying: Check if we have to do a color keyed blt,
3189          * and if not check if a color key is activated.
3190          *
3191          * Just modify the color keying parameters in the surface and restore them afterwards
3192          * The surface keeps track of the color key last used to load the opengl surface.
3193          * PreLoad will catch the change to the flags and color key and reload if necessary.
3194          */
3195         if(Flags & WINEDDBLT_KEYSRC) {
3196             /* Use color key from surface */
3197         } else if(Flags & WINEDDBLT_KEYSRCOVERRIDE) {
3198             /* Use color key from DDBltFx */
3199             Src->CKeyFlags |= WINEDDSD_CKSRCBLT;
3200             This->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3201         } else {
3202             /* Do not use color key */
3203             Src->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3204         }
3205
3206         /* Now load the surface */
3207         IWineD3DSurface_PreLoad((IWineD3DSurface *) Src);
3208
3209
3210         /* Activate the destination context, set it up for blitting */
3211         ActivateContext(myDevice, (IWineD3DSurface *) This, CTXUSAGE_BLIT);
3212         ENTER_GL();
3213
3214         if(!dstSwapchain) {
3215             TRACE("Drawing to offscreen buffer\n");
3216             glDrawBuffer(myDevice->offscreenBuffer);
3217             checkGLcall("glDrawBuffer");
3218         } else {
3219             GLenum buffer = surface_get_gl_buffer((IWineD3DSurface *)This, (IWineD3DSwapChain *)dstSwapchain);
3220             TRACE("Drawing to %#x buffer\n", buffer);
3221             glDrawBuffer(buffer);
3222             checkGLcall("glDrawBuffer");
3223         }
3224
3225         /* Bind the texture */
3226         glBindTexture(GL_TEXTURE_2D, Src->glDescription.textureName);
3227         checkGLcall("glBindTexture");
3228
3229         /* Filtering for StretchRect */
3230         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
3231                         stateLookup[WINELOOKUP_MAGFILTER][Filter - minLookup[WINELOOKUP_MAGFILTER]]);
3232         checkGLcall("glTexParameteri");
3233         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
3234                         minMipLookup[Filter][WINED3DTEXF_NONE]);
3235         checkGLcall("glTexParameteri");
3236         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
3237         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
3238         glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
3239         checkGLcall("glTexEnvi");
3240
3241         /* This is for color keying */
3242         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3243             glEnable(GL_ALPHA_TEST);
3244             checkGLcall("glEnable GL_ALPHA_TEST");
3245             glAlphaFunc(GL_NOTEQUAL, 0.0);
3246             checkGLcall("glAlphaFunc\n");
3247         } else {
3248             glDisable(GL_ALPHA_TEST);
3249             checkGLcall("glDisable GL_ALPHA_TEST");
3250         }
3251
3252         /* Draw a textured quad
3253          */
3254         glBegin(GL_QUADS);
3255
3256         glColor3d(1.0f, 1.0f, 1.0f);
3257         glTexCoord2f(glTexCoord[0], glTexCoord[2]);
3258         glVertex3f(rect.x1,
3259                     rect.y1,
3260                     0.0);
3261
3262         glTexCoord2f(glTexCoord[0], glTexCoord[3]);
3263         glVertex3f(rect.x1, rect.y2, 0.0);
3264
3265         glTexCoord2f(glTexCoord[1], glTexCoord[3]);
3266         glVertex3f(rect.x2,
3267                     rect.y2,
3268                     0.0);
3269
3270         glTexCoord2f(glTexCoord[1], glTexCoord[2]);
3271         glVertex3f(rect.x2,
3272                     rect.y1,
3273                     0.0);
3274         glEnd();
3275         checkGLcall("glEnd");
3276
3277         if(Flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE)) {
3278             glDisable(GL_ALPHA_TEST);
3279             checkGLcall("glDisable(GL_ALPHA_TEST)");
3280         }
3281
3282         /* Unbind the texture */
3283         glBindTexture(GL_TEXTURE_2D, 0);
3284         checkGLcall("glEnable glBindTexture");
3285
3286         /* The draw buffer should only need to be restored if we were drawing to the front buffer, and there is a back buffer.
3287          * otherwise the context manager should choose between GL_BACK / offscreenDrawBuffer
3288          */
3289         if(dstSwapchain && This == (IWineD3DSurfaceImpl *) dstSwapchain->frontBuffer && dstSwapchain->backBuffer) {
3290             glDrawBuffer(GL_BACK);
3291             checkGLcall("glDrawBuffer");
3292         }
3293         /* Restore the color key parameters */
3294         Src->CKeyFlags = oldCKeyFlags;
3295         This->SrcBltCKey = oldBltCKey;
3296
3297         LEAVE_GL();
3298
3299         /* TODO: If the surface is locked often, perform the Blt in software on the memory instead */
3300         This->Flags &= ~SFLAG_INSYSMEM;
3301         /* The surface is now in the drawable. On onscreen surfaces or without fbos the texture
3302          * is outdated now
3303          */
3304         if(dstSwapchain || wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
3305             This->Flags |= SFLAG_INDRAWABLE;
3306             This->Flags &= ~SFLAG_INTEXTURE;
3307         } else {
3308             This->Flags |= SFLAG_INTEXTURE;
3309         }
3310
3311         return WINED3D_OK;
3312     } else {
3313         /* Source-Less Blit to render target */
3314         if (Flags & WINEDDBLT_COLORFILL) {
3315             /* This is easy to handle for the D3D Device... */
3316             DWORD color;
3317
3318             TRACE("Colorfill\n");
3319
3320             /* The color as given in the Blt function is in the format of the frame-buffer...
3321              * 'clear' expect it in ARGB format => we need to do some conversion :-)
3322              */
3323             if (This->resource.format == WINED3DFMT_P8) {
3324                 if (This->palette) {
3325                     color = ((0xFF000000) |
3326                             (This->palette->palents[DDBltFx->u5.dwFillColor].peRed << 16) |
3327                             (This->palette->palents[DDBltFx->u5.dwFillColor].peGreen << 8) |
3328                             (This->palette->palents[DDBltFx->u5.dwFillColor].peBlue));
3329                 } else {
3330                     color = 0xFF000000;
3331                 }
3332             }
3333             else if (This->resource.format == WINED3DFMT_R5G6B5) {
3334                 if (DDBltFx->u5.dwFillColor == 0xFFFF) {
3335                     color = 0xFFFFFFFF;
3336                 } else {
3337                     color = ((0xFF000000) |
3338                             ((DDBltFx->u5.dwFillColor & 0xF800) << 8) |
3339                             ((DDBltFx->u5.dwFillColor & 0x07E0) << 5) |
3340                             ((DDBltFx->u5.dwFillColor & 0x001F) << 3));
3341                 }
3342             }
3343             else if ((This->resource.format == WINED3DFMT_R8G8B8) ||
3344                     (This->resource.format == WINED3DFMT_X8R8G8B8) ) {
3345                 color = 0xFF000000 | DDBltFx->u5.dwFillColor;
3346             }
3347             else if (This->resource.format == WINED3DFMT_A8R8G8B8) {
3348                 color = DDBltFx->u5.dwFillColor;
3349             }
3350             else {
3351                 ERR("Wrong surface type for BLT override(Format doesn't match) !\n");
3352                 return WINED3DERR_INVALIDCALL;
3353             }
3354
3355             TRACE("Calling GetSwapChain with mydevice = %p\n", myDevice);
3356             if(dstSwapchain && dstSwapchain->backBuffer && This == (IWineD3DSurfaceImpl*) dstSwapchain->backBuffer[0]) {
3357                 glDrawBuffer(GL_BACK);
3358                 checkGLcall("glDrawBuffer(GL_BACK)");
3359             } else if (dstSwapchain && This == (IWineD3DSurfaceImpl*) dstSwapchain->frontBuffer) {
3360                 glDrawBuffer(GL_FRONT);
3361                 checkGLcall("glDrawBuffer(GL_FRONT)");
3362             } else if(This == (IWineD3DSurfaceImpl *) myDevice->render_targets[0]) {
3363                 glDrawBuffer(myDevice->offscreenBuffer);
3364                 checkGLcall("glDrawBuffer(myDevice->offscreenBuffer3)");
3365             } else {
3366                 TRACE("Surface is higher back buffer, falling back to software\n");
3367                 return WINED3DERR_INVALIDCALL;
3368             }
3369
3370             TRACE("(%p) executing Render Target override, color = %x\n", This, color);
3371
3372             IWineD3DDevice_Clear( (IWineD3DDevice *) myDevice,
3373                                 1 /* Number of rectangles */,
3374                                 &rect,
3375                                 WINED3DCLEAR_TARGET,
3376                                 color,
3377                                 0.0 /* Z */,
3378                                 0 /* Stencil */);
3379
3380             /* Restore the original draw buffer */
3381             if(!dstSwapchain) {
3382                 glDrawBuffer(myDevice->offscreenBuffer);
3383             } else if(dstSwapchain->backBuffer && dstSwapchain->backBuffer[0]) {
3384                 glDrawBuffer(GL_BACK);
3385             }
3386             vcheckGLcall("glDrawBuffer");
3387
3388             return WINED3D_OK;
3389         }
3390     }
3391
3392     /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3393     TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3394     return WINED3DERR_INVALIDCALL;
3395 }
3396
3397 static HRESULT WINAPI IWineD3DSurfaceImpl_BltZ(IWineD3DSurfaceImpl *This, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx)
3398 {
3399     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3400     float depth;
3401
3402     if (Flags & WINEDDBLT_DEPTHFILL) {
3403         switch(This->resource.format) {
3404             case WINED3DFMT_D16:
3405                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000ffff;
3406                 break;
3407             case WINED3DFMT_D15S1:
3408                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x0000fffe;
3409                 break;
3410             case WINED3DFMT_D24S8:
3411             case WINED3DFMT_D24X8:
3412                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0x00ffffff;
3413                 break;
3414             case WINED3DFMT_D32:
3415                 depth = (float) DDBltFx->u5.dwFillDepth / (float) 0xffffffff;
3416                 break;
3417             default:
3418                 depth = 0.0;
3419                 ERR("Unexpected format for depth fill: %s\n", debug_d3dformat(This->resource.format));
3420         }
3421
3422         return IWineD3DDevice_Clear((IWineD3DDevice *) myDevice,
3423                                     DestRect == NULL ? 0 : 1,
3424                                     (WINED3DRECT *) DestRect,
3425                                     WINED3DCLEAR_ZBUFFER,
3426                                     0x00000000,
3427                                     depth,
3428                                     0x00000000);
3429     }
3430
3431     FIXME("(%p): Unsupp depthstencil blit\n", This);
3432     return WINED3DERR_INVALIDCALL;
3433 }
3434
3435 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter) {
3436     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
3437     IWineD3DSurfaceImpl *Src = (IWineD3DSurfaceImpl *) SrcSurface;
3438     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3439     TRACE("(%p)->(%p,%p,%p,%x,%p)\n", This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx);
3440     TRACE("(%p): Usage is %s\n", This, debug_d3dusage(This->resource.usage));
3441
3442     /* Accessing the depth stencil is supposed to fail between a BeginScene and EndScene pair,
3443      * except depth blits, which seem to work
3444      */
3445     if(iface == myDevice->stencilBufferTarget || (SrcSurface && SrcSurface == myDevice->stencilBufferTarget)) {
3446         if(myDevice->inScene && !(Flags & WINEDDBLT_DEPTHFILL)) {
3447             TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3448             return WINED3DERR_INVALIDCALL;
3449         } else if(IWineD3DSurfaceImpl_BltZ(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx) == WINED3D_OK) {
3450             TRACE("Z Blit override handled the blit\n");
3451             return WINED3D_OK;
3452         }
3453     }
3454
3455     /* Special cases for RenderTargets */
3456     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3457         ( Src && (Src->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3458         if(IWineD3DSurfaceImpl_BltOverride(This, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter) == WINED3D_OK) return WINED3D_OK;
3459     }
3460
3461     /* For the rest call the X11 surface implementation.
3462      * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
3463      * other Blts are rather rare
3464      */
3465     return IWineGDISurfaceImpl_Blt(iface, DestRect, SrcSurface, SrcRect, Flags, DDBltFx, Filter);
3466 }
3467
3468 HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans) {
3469     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3470     IWineD3DSurfaceImpl *srcImpl = (IWineD3DSurfaceImpl *) Source;
3471     IWineD3DDeviceImpl *myDevice = This->resource.wineD3DDevice;
3472     TRACE("(%p)->(%d, %d, %p, %p, %08x\n", iface, dstx, dsty, Source, rsrc, trans);
3473
3474     if(myDevice->inScene &&
3475        (iface == myDevice->stencilBufferTarget ||
3476        (Source && Source == myDevice->stencilBufferTarget))) {
3477         TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
3478         return WINED3DERR_INVALIDCALL;
3479     }
3480
3481     /* Special cases for RenderTargets */
3482     if( (This->resource.usage & WINED3DUSAGE_RENDERTARGET) ||
3483         ( srcImpl && (srcImpl->resource.usage & WINED3DUSAGE_RENDERTARGET) )) {
3484
3485         RECT SrcRect, DstRect;
3486         DWORD Flags=0;
3487
3488         if(rsrc) {
3489             SrcRect.left = rsrc->left;
3490             SrcRect.top= rsrc->top;
3491             SrcRect.bottom = rsrc->bottom;
3492             SrcRect.right = rsrc->right;
3493         } else {
3494             SrcRect.left = 0;
3495             SrcRect.top = 0;
3496             SrcRect.right = srcImpl->currentDesc.Width;
3497             SrcRect.bottom = srcImpl->currentDesc.Height;
3498         }
3499
3500         DstRect.left = dstx;
3501         DstRect.top=dsty;
3502         DstRect.right = dstx + SrcRect.right - SrcRect.left;
3503         DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
3504
3505         /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
3506         if(trans & WINEDDBLTFAST_SRCCOLORKEY)
3507             Flags |= WINEDDBLT_KEYSRC;
3508         if(trans & WINEDDBLTFAST_DESTCOLORKEY)
3509             Flags |= WINEDDBLT_KEYDEST;
3510         if(trans & WINEDDBLTFAST_WAIT)
3511             Flags |= WINEDDBLT_WAIT;
3512         if(trans & WINEDDBLTFAST_DONOTWAIT)
3513             Flags |= WINEDDBLT_DONOTWAIT;
3514
3515         if(IWineD3DSurfaceImpl_BltOverride(This, &DstRect, Source, &SrcRect, Flags, NULL, WINED3DTEXF_POINT) == WINED3D_OK) return WINED3D_OK;
3516     }
3517
3518
3519     return IWineGDISurfaceImpl_BltFast(iface, dstx, dsty, Source, rsrc, trans);
3520 }
3521
3522 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
3523     /** Check against the maximum texture sizes supported by the video card **/
3524     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
3525     unsigned int pow2Width, pow2Height;
3526     const GlPixelFormatDesc *glDesc;
3527
3528     getFormatDescEntry(This->resource.format, &GLINFO_LOCATION, &glDesc);
3529     /* Setup some glformat defaults */
3530     This->glDescription.glFormat         = glDesc->glFormat;
3531     This->glDescription.glFormatInternal = glDesc->glInternal;
3532     This->glDescription.glType           = glDesc->glType;
3533
3534     This->glDescription.textureName      = 0;
3535     This->glDescription.target           = GL_TEXTURE_2D;
3536
3537     /* Non-power2 support */
3538     if (GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
3539         pow2Width = This->currentDesc.Width;
3540         pow2Height = This->currentDesc.Height;
3541     } else {
3542         /* Find the nearest pow2 match */
3543         pow2Width = pow2Height = 1;
3544         while (pow2Width < This->currentDesc.Width) pow2Width <<= 1;
3545         while (pow2Height < This->currentDesc.Height) pow2Height <<= 1;
3546     }
3547     This->pow2Width  = pow2Width;
3548     This->pow2Height = pow2Height;
3549
3550     if (pow2Width > This->currentDesc.Width || pow2Height > This->currentDesc.Height) {
3551         WINED3DFORMAT Format = This->resource.format;
3552         /** TODO: add support for non power two compressed textures **/
3553         if (Format == WINED3DFMT_DXT1 || Format == WINED3DFMT_DXT2 || Format == WINED3DFMT_DXT3
3554             || Format == WINED3DFMT_DXT4 || Format == WINED3DFMT_DXT5) {
3555             FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
3556                   This, This->currentDesc.Width, This->currentDesc.Height);
3557             return WINED3DERR_NOTAVAILABLE;
3558         }
3559     }
3560
3561     if(pow2Width != This->currentDesc.Width ||
3562        pow2Height != This->currentDesc.Height) {
3563         This->Flags |= SFLAG_NONPOW2;
3564     }
3565
3566     TRACE("%p\n", This);
3567     if ((This->pow2Width > GL_LIMITS(texture_size) || This->pow2Height > GL_LIMITS(texture_size)) && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))) {
3568         /* one of three options
3569         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)
3570         2: Set the texture to the maximum size (bad idea)
3571         3:    WARN and return WINED3DERR_NOTAVAILABLE;
3572         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.
3573         */
3574         WARN("(%p) Creating an oversized surface\n", This);
3575         This->Flags |= SFLAG_OVERSIZE;
3576
3577         /* This will be initialized on the first blt */
3578         This->glRect.left = 0;
3579         This->glRect.top = 0;
3580         This->glRect.right = 0;
3581         This->glRect.bottom = 0;
3582     } else {
3583         /* No oversize, gl rect is the full texture size */
3584         This->Flags &= ~SFLAG_OVERSIZE;
3585         This->glRect.left = 0;
3586         This->glRect.top = 0;
3587         This->glRect.right = This->pow2Width;
3588         This->glRect.bottom = This->pow2Height;
3589     }
3590
3591     if(This->resource.allocatedMemory == NULL) {
3592         /* Make sure memory exists from the start, and it is initialized properly. D3D initializes surfaces,
3593          * gl does not, so we need to upload zeroes to init the gl texture.
3594          */
3595         This->resource.allocatedMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->resource.size + 4);
3596     }
3597     This->Flags |= SFLAG_INSYSMEM;
3598
3599     return WINED3D_OK;
3600 }
3601
3602 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
3603 {
3604     /* IUnknown */
3605     IWineD3DBaseSurfaceImpl_QueryInterface,
3606     IWineD3DBaseSurfaceImpl_AddRef,
3607     IWineD3DSurfaceImpl_Release,
3608     /* IWineD3DResource */
3609     IWineD3DBaseSurfaceImpl_GetParent,
3610     IWineD3DBaseSurfaceImpl_GetDevice,
3611     IWineD3DBaseSurfaceImpl_SetPrivateData,
3612     IWineD3DBaseSurfaceImpl_GetPrivateData,
3613     IWineD3DBaseSurfaceImpl_FreePrivateData,
3614     IWineD3DBaseSurfaceImpl_SetPriority,
3615     IWineD3DBaseSurfaceImpl_GetPriority,
3616     IWineD3DSurfaceImpl_PreLoad,
3617     IWineD3DBaseSurfaceImpl_GetType,
3618     /* IWineD3DSurface */
3619     IWineD3DBaseSurfaceImpl_GetContainer,
3620     IWineD3DBaseSurfaceImpl_GetDesc,
3621     IWineD3DSurfaceImpl_LockRect,
3622     IWineD3DSurfaceImpl_UnlockRect,
3623     IWineD3DSurfaceImpl_GetDC,
3624     IWineD3DSurfaceImpl_ReleaseDC,
3625     IWineD3DSurfaceImpl_Flip,
3626     IWineD3DSurfaceImpl_Blt,
3627     IWineD3DBaseSurfaceImpl_GetBltStatus,
3628     IWineD3DBaseSurfaceImpl_GetFlipStatus,
3629     IWineD3DBaseSurfaceImpl_IsLost,
3630     IWineD3DBaseSurfaceImpl_Restore,
3631     IWineD3DSurfaceImpl_BltFast,
3632     IWineD3DBaseSurfaceImpl_GetPalette,
3633     IWineD3DBaseSurfaceImpl_SetPalette,
3634     IWineD3DBaseSurfaceImpl_RealizePalette,
3635     IWineD3DBaseSurfaceImpl_SetColorKey,
3636     IWineD3DBaseSurfaceImpl_GetPitch,
3637     IWineD3DSurfaceImpl_SetMem,
3638     IWineD3DBaseSurfaceImpl_SetOverlayPosition,
3639     IWineD3DBaseSurfaceImpl_GetOverlayPosition,
3640     IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
3641     IWineD3DBaseSurfaceImpl_UpdateOverlay,
3642     IWineD3DBaseSurfaceImpl_SetClipper,
3643     IWineD3DBaseSurfaceImpl_GetClipper,
3644     /* Internal use: */
3645     IWineD3DSurfaceImpl_AddDirtyRect,
3646     IWineD3DSurfaceImpl_LoadTexture,
3647     IWineD3DSurfaceImpl_SaveSnapshot,
3648     IWineD3DBaseSurfaceImpl_SetContainer,
3649     IWineD3DSurfaceImpl_SetGlTextureDesc,
3650     IWineD3DSurfaceImpl_GetGlDesc,
3651     IWineD3DSurfaceImpl_GetData,
3652     IWineD3DSurfaceImpl_SetFormat,
3653     IWineD3DSurfaceImpl_PrivateSetup
3654 };