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