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-2008 Stefan Dösinger for CodeWeavers
  11  * Copyright 2007-2008 Henri Verbeet
  12  * Copyright 2006-2008 Roderick Colenbrander
  13  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
  14  *
  15  * This library is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU Lesser General Public
  17  * License as published by the Free Software Foundation; either
  18  * version 2.1 of the License, or (at your option) any later version.
  19  *
  20  * This library is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  23  * Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public
  26  * License along with this library; if not, write to the Free Software
  27  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  28  */
  29
  30 #include "config.h"
  31 #include "wine/port.h"
  32 #include "wined3d_private.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(d3d_surface);
  35 WINE_DECLARE_DEBUG_CHANNEL(d3d);
  36
  37 static void surface_cleanup(IWineD3DSurfaceImpl *This)
  38 {
  39     TRACE("(%p) : Cleaning up.\n", This);
  40
  41     if (This->texture_name || (This->flags & SFLAG_PBO) || !list_empty(&This->renderbuffers))
  42     {
  43         const struct wined3d_gl_info *gl_info;
  44         renderbuffer_entry_t *entry, *entry2;
  45         struct wined3d_context *context;
  46
  47         context = context_acquire(This->resource.device, NULL);
  48         gl_info = context->gl_info;
  49
  50         ENTER_GL();
  51
  52         if (This->texture_name)
  53         {
  54             TRACE("Deleting texture %u.\n", This->texture_name);
  55             glDeleteTextures(1, &This->texture_name);
  56         }
  57
  58         if (This->flags & SFLAG_PBO)
  59         {
  60             TRACE("Deleting PBO %u.\n", This->pbo);
  61             GL_EXTCALL(glDeleteBuffersARB(1, &This->pbo));
  62         }
  63
  64         LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &This->renderbuffers, renderbuffer_entry_t, entry)
  65         {
  66             TRACE("Deleting renderbuffer %u.\n", entry->id);
  67             gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
  68             HeapFree(GetProcessHeap(), 0, entry);
  69         }
  70
  71         LEAVE_GL();
  72
  73         context_release(context);
  74     }
  75
  76     if (This->flags & SFLAG_DIBSECTION)
  77     {
  78         /* Release the DC. */
  79         SelectObject(This->hDC, This->dib.holdbitmap);
  80         DeleteDC(This->hDC);
  81         /* Release the DIB section. */
  82         DeleteObject(This->dib.DIBsection);
  83         This->dib.bitmap_data = NULL;
  84         This->resource.allocatedMemory = NULL;
  85     }
  86
  87     if (This->flags & SFLAG_USERPTR) IWineD3DSurface_SetMem((IWineD3DSurface *)This, NULL);
  88     if (This->overlay_dest) list_remove(&This->overlay_entry);
  89
  90     HeapFree(GetProcessHeap(), 0, This->palette9);
  91
  92     resource_cleanup(&This->resource);
  93 }
  94
  95 void surface_set_container(IWineD3DSurfaceImpl *surface, enum wined3d_container_type type, void *container)
  96 {
  97     TRACE("surface %p, container %p.\n", surface, container);
  98
  99     if (!container && type != WINED3D_CONTAINER_NONE)
 100         ERR("Setting NULL container of type %#x.\n", type);
 101
 102     if (type == WINED3D_CONTAINER_SWAPCHAIN)
 103     {
 104         surface->get_drawable_size = get_drawable_size_swapchain;
 105     }
 106     else
 107     {
 108         switch (wined3d_settings.offscreen_rendering_mode)
 109         {
 110             case ORM_FBO:
 111                 surface->get_drawable_size = get_drawable_size_fbo;
 112                 break;
 113
 114             case ORM_BACKBUFFER:
 115                 surface->get_drawable_size = get_drawable_size_backbuffer;
 116                 break;
 117
 118             default:
 119                 ERR("Unhandled offscreen rendering mode %#x.\n", wined3d_settings.offscreen_rendering_mode);
 120                 return;
 121         }
 122     }
 123
 124     surface->container.type = type;
 125     surface->container.u.base = container;
 126 }
 127
 128 struct blt_info
 129 {
 130     GLenum binding;
 131     GLenum bind_target;
 132     enum tex_types tex_type;
 133     GLfloat coords[4][3];
 134 };
 135
 136 struct float_rect
 137 {
 138     float l;
 139     float t;
 140     float r;
 141     float b;
 142 };
 143
 144 static inline void cube_coords_float(const RECT *r, UINT w, UINT h, struct float_rect *f)
 145 {
 146     f->l = ((r->left * 2.0f) / w) - 1.0f;
 147     f->t = ((r->top * 2.0f) / h) - 1.0f;
 148     f->r = ((r->right * 2.0f) / w) - 1.0f;
 149     f->b = ((r->bottom * 2.0f) / h) - 1.0f;
 150 }
 151
 152 static void surface_get_blt_info(GLenum target, const RECT *rect, GLsizei w, GLsizei h, struct blt_info *info)
 153 {
 154     GLfloat (*coords)[3] = info->coords;
 155     struct float_rect f;
 156
 157     switch (target)
 158     {
 159         default:
 160             FIXME("Unsupported texture target %#x\n", target);
 161             /* Fall back to GL_TEXTURE_2D */
 162         case GL_TEXTURE_2D:
 163             info->binding = GL_TEXTURE_BINDING_2D;
 164             info->bind_target = GL_TEXTURE_2D;
 165             info->tex_type = tex_2d;
 166             coords[0][0] = (float)rect->left / w;
 167             coords[0][1] = (float)rect->top / h;
 168             coords[0][2] = 0.0f;
 169
 170             coords[1][0] = (float)rect->right / w;
 171             coords[1][1] = (float)rect->top / h;
 172             coords[1][2] = 0.0f;
 173
 174             coords[2][0] = (float)rect->left / w;
 175             coords[2][1] = (float)rect->bottom / h;
 176             coords[2][2] = 0.0f;
 177
 178             coords[3][0] = (float)rect->right / w;
 179             coords[3][1] = (float)rect->bottom / h;
 180             coords[3][2] = 0.0f;
 181             break;
 182
 183         case GL_TEXTURE_RECTANGLE_ARB:
 184             info->binding = GL_TEXTURE_BINDING_RECTANGLE_ARB;
 185             info->bind_target = GL_TEXTURE_RECTANGLE_ARB;
 186             info->tex_type = tex_rect;
 187             coords[0][0] = rect->left;  coords[0][1] = rect->top;       coords[0][2] = 0.0f;
 188             coords[1][0] = rect->right; coords[1][1] = rect->top;       coords[1][2] = 0.0f;
 189             coords[2][0] = rect->left;  coords[2][1] = rect->bottom;    coords[2][2] = 0.0f;
 190             coords[3][0] = rect->right; coords[3][1] = rect->bottom;    coords[3][2] = 0.0f;
 191             break;
 192
 193         case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
 194             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 195             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 196             info->tex_type = tex_cube;
 197             cube_coords_float(rect, w, h, &f);
 198
 199             coords[0][0] =  1.0f;   coords[0][1] = -f.t;   coords[0][2] = -f.l;
 200             coords[1][0] =  1.0f;   coords[1][1] = -f.t;   coords[1][2] = -f.r;
 201             coords[2][0] =  1.0f;   coords[2][1] = -f.b;   coords[2][2] = -f.l;
 202             coords[3][0] =  1.0f;   coords[3][1] = -f.b;   coords[3][2] = -f.r;
 203             break;
 204
 205         case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
 206             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 207             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 208             info->tex_type = tex_cube;
 209             cube_coords_float(rect, w, h, &f);
 210
 211             coords[0][0] = -1.0f;   coords[0][1] = -f.t;   coords[0][2] = f.l;
 212             coords[1][0] = -1.0f;   coords[1][1] = -f.t;   coords[1][2] = f.r;
 213             coords[2][0] = -1.0f;   coords[2][1] = -f.b;   coords[2][2] = f.l;
 214             coords[3][0] = -1.0f;   coords[3][1] = -f.b;   coords[3][2] = f.r;
 215             break;
 216
 217         case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
 218             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 219             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 220             info->tex_type = tex_cube;
 221             cube_coords_float(rect, w, h, &f);
 222
 223             coords[0][0] = f.l;   coords[0][1] =  1.0f;   coords[0][2] = f.t;
 224             coords[1][0] = f.r;   coords[1][1] =  1.0f;   coords[1][2] = f.t;
 225             coords[2][0] = f.l;   coords[2][1] =  1.0f;   coords[2][2] = f.b;
 226             coords[3][0] = f.r;   coords[3][1] =  1.0f;   coords[3][2] = f.b;
 227             break;
 228
 229         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
 230             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 231             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 232             info->tex_type = tex_cube;
 233             cube_coords_float(rect, w, h, &f);
 234
 235             coords[0][0] = f.l;   coords[0][1] = -1.0f;   coords[0][2] = -f.t;
 236             coords[1][0] = f.r;   coords[1][1] = -1.0f;   coords[1][2] = -f.t;
 237             coords[2][0] = f.l;   coords[2][1] = -1.0f;   coords[2][2] = -f.b;
 238             coords[3][0] = f.r;   coords[3][1] = -1.0f;   coords[3][2] = -f.b;
 239             break;
 240
 241         case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
 242             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 243             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 244             info->tex_type = tex_cube;
 245             cube_coords_float(rect, w, h, &f);
 246
 247             coords[0][0] = f.l;   coords[0][1] = -f.t;   coords[0][2] =  1.0f;
 248             coords[1][0] = f.r;   coords[1][1] = -f.t;   coords[1][2] =  1.0f;
 249             coords[2][0] = f.l;   coords[2][1] = -f.b;   coords[2][2] =  1.0f;
 250             coords[3][0] = f.r;   coords[3][1] = -f.b;   coords[3][2] =  1.0f;
 251             break;
 252
 253         case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
 254             info->binding = GL_TEXTURE_BINDING_CUBE_MAP_ARB;
 255             info->bind_target = GL_TEXTURE_CUBE_MAP_ARB;
 256             info->tex_type = tex_cube;
 257             cube_coords_float(rect, w, h, &f);
 258
 259             coords[0][0] = -f.l;   coords[0][1] = -f.t;   coords[0][2] = -1.0f;
 260             coords[1][0] = -f.r;   coords[1][1] = -f.t;   coords[1][2] = -1.0f;
 261             coords[2][0] = -f.l;   coords[2][1] = -f.b;   coords[2][2] = -1.0f;
 262             coords[3][0] = -f.r;   coords[3][1] = -f.b;   coords[3][2] = -1.0f;
 263             break;
 264     }
 265 }
 266
 267 static inline void surface_get_rect(IWineD3DSurfaceImpl *This, const RECT *rect_in, RECT *rect_out)
 268 {
 269     if (rect_in)
 270         *rect_out = *rect_in;
 271     else
 272     {
 273         rect_out->left = 0;
 274         rect_out->top = 0;
 275         rect_out->right = This->resource.width;
 276         rect_out->bottom = This->resource.height;
 277     }
 278 }
 279
 280 /* GL locking and context activation is done by the caller */
 281 void draw_textured_quad(IWineD3DSurfaceImpl *src_surface, const RECT *src_rect, const RECT *dst_rect, WINED3DTEXTUREFILTERTYPE Filter)
 282 {
 283     struct blt_info info;
 284
 285     surface_get_blt_info(src_surface->texture_target, src_rect, src_surface->pow2Width, src_surface->pow2Height, &info);
 286
 287     glEnable(info.bind_target);
 288     checkGLcall("glEnable(bind_target)");
 289
 290     /* Bind the texture */
 291     glBindTexture(info.bind_target, src_surface->texture_name);
 292     checkGLcall("glBindTexture");
 293
 294     /* Filtering for StretchRect */
 295     glTexParameteri(info.bind_target, GL_TEXTURE_MAG_FILTER,
 296             wined3d_gl_mag_filter(magLookup, Filter));
 297     checkGLcall("glTexParameteri");
 298     glTexParameteri(info.bind_target, GL_TEXTURE_MIN_FILTER,
 299             wined3d_gl_min_mip_filter(minMipLookup, Filter, WINED3DTEXF_NONE));
 300     checkGLcall("glTexParameteri");
 301     glTexParameteri(info.bind_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
 302     glTexParameteri(info.bind_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
 303     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
 304     checkGLcall("glTexEnvi");
 305
 306     /* Draw a quad */
 307     glBegin(GL_TRIANGLE_STRIP);
 308     glTexCoord3fv(info.coords[0]);
 309     glVertex2i(dst_rect->left, dst_rect->top);
 310
 311     glTexCoord3fv(info.coords[1]);
 312     glVertex2i(dst_rect->right, dst_rect->top);
 313
 314     glTexCoord3fv(info.coords[2]);
 315     glVertex2i(dst_rect->left, dst_rect->bottom);
 316
 317     glTexCoord3fv(info.coords[3]);
 318     glVertex2i(dst_rect->right, dst_rect->bottom);
 319     glEnd();
 320
 321     /* Unbind the texture */
 322     glBindTexture(info.bind_target, 0);
 323     checkGLcall("glBindTexture(info->bind_target, 0)");
 324
 325     /* We changed the filtering settings on the texture. Inform the
 326      * container about this to get the filters reset properly next draw. */
 327     if (src_surface->container.type == WINED3D_CONTAINER_TEXTURE)
 328     {
 329         struct wined3d_texture *texture = src_surface->container.u.texture;
 330         texture->texture_rgb.states[WINED3DTEXSTA_MAGFILTER] = WINED3DTEXF_POINT;
 331         texture->texture_rgb.states[WINED3DTEXSTA_MINFILTER] = WINED3DTEXF_POINT;
 332         texture->texture_rgb.states[WINED3DTEXSTA_MIPFILTER] = WINED3DTEXF_NONE;
 333     }
 334 }
 335
 336 static void surface_realize_palette(IWineD3DSurfaceImpl *surface)
 337 {
 338     struct wined3d_palette *palette = surface->palette;
 339
 340     TRACE("surface %p.\n", surface);
 341
 342     if (!palette) return;
 343
 344     if (surface->resource.format->id == WINED3DFMT_P8_UINT
 345             || surface->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
 346     {
 347         if (surface->resource.usage & WINED3DUSAGE_RENDERTARGET)
 348         {
 349             /* Make sure the texture is up to date. This call doesn't do
 350              * anything if the texture is already up to date. */
 351             surface_load_location(surface, SFLAG_INTEXTURE, NULL);
 352
 353             /* We want to force a palette refresh, so mark the drawable as not being up to date */
 354             surface_modify_location(surface, SFLAG_INDRAWABLE, FALSE);
 355         }
 356         else
 357         {
 358             if (!(surface->flags & SFLAG_INSYSMEM))
 359             {
 360                 TRACE("Palette changed with surface that does not have an up to date system memory copy.\n");
 361                 surface_load_location(surface, SFLAG_INSYSMEM, NULL);
 362             }
 363             surface_modify_location(surface, SFLAG_INSYSMEM, TRUE);
 364         }
 365     }
 366
 367     if (surface->flags & SFLAG_DIBSECTION)
 368     {
 369         RGBQUAD col[256];
 370         unsigned int i;
 371
 372         TRACE("Updating the DC's palette.\n");
 373
 374         for (i = 0; i < 256; ++i)
 375         {
 376             col[i].rgbRed   = palette->palents[i].peRed;
 377             col[i].rgbGreen = palette->palents[i].peGreen;
 378             col[i].rgbBlue  = palette->palents[i].peBlue;
 379             col[i].rgbReserved = 0;
 380         }
 381         SetDIBColorTable(surface->hDC, 0, 256, col);
 382     }
 383
 384     /* Propagate the changes to the drawable when we have a palette. */
 385     if (surface->resource.usage & WINED3DUSAGE_RENDERTARGET)
 386         surface_load_location(surface, SFLAG_INDRAWABLE, NULL);
 387 }
 388
 389 static HRESULT surface_draw_overlay(IWineD3DSurfaceImpl *surface)
 390 {
 391     HRESULT hr;
 392
 393     /* If there's no destination surface there is nothing to do. */
 394     if (!surface->overlay_dest)
 395         return WINED3D_OK;
 396
 397     /* Blt calls ModifyLocation on the dest surface, which in turn calls
 398      * DrawOverlay to update the overlay. Prevent an endless recursion. */
 399     if (surface->overlay_dest->flags & SFLAG_INOVERLAYDRAW)
 400         return WINED3D_OK;
 401
 402     surface->overlay_dest->flags |= SFLAG_INOVERLAYDRAW;
 403     hr = IWineD3DSurface_Blt((IWineD3DSurface *)surface->overlay_dest,
 404             &surface->overlay_destrect, (IWineD3DSurface *)surface, &surface->overlay_srcrect,
 405             WINEDDBLT_WAIT, NULL, WINED3DTEXF_LINEAR);
 406     surface->overlay_dest->flags &= ~SFLAG_INOVERLAYDRAW;
 407
 408     return hr;
 409 }
 410
 411 /* Context activation is done by the caller. */
 412 static void surface_remove_pbo(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info)
 413 {
 414     if (!surface->resource.heapMemory)
 415     {
 416         surface->resource.heapMemory = HeapAlloc(GetProcessHeap(), 0, surface->resource.size + RESOURCE_ALIGNMENT);
 417         surface->resource.allocatedMemory = (BYTE *)(((ULONG_PTR)surface->resource.heapMemory
 418                 + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
 419     }
 420
 421     ENTER_GL();
 422     GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, surface->pbo));
 423     checkGLcall("glBindBufferARB(GL_PIXEL_UNPACK_BUFFER, surface->pbo)");
 424     GL_EXTCALL(glGetBufferSubDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0,
 425             surface->resource.size, surface->resource.allocatedMemory));
 426     checkGLcall("glGetBufferSubDataARB");
 427     GL_EXTCALL(glDeleteBuffersARB(1, &surface->pbo));
 428     checkGLcall("glDeleteBuffersARB");
 429     LEAVE_GL();
 430
 431     surface->pbo = 0;
 432     surface->flags &= ~SFLAG_PBO;
 433 }
 434
 435 /* Do not call while under the GL lock. */
 436 static void surface_unload(struct wined3d_resource *resource)
 437 {
 438     IWineD3DSurfaceImpl *surface = surface_from_resource(resource);
 439     IWineD3DDeviceImpl *device = resource->device;
 440     const struct wined3d_gl_info *gl_info;
 441     renderbuffer_entry_t *entry, *entry2;
 442     struct wined3d_context *context;
 443
 444     TRACE("surface %p.\n", surface);
 445
 446     if (resource->pool == WINED3DPOOL_DEFAULT)
 447     {
 448         /* Default pool resources are supposed to be destroyed before Reset is called.
 449          * Implicit resources stay however. So this means we have an implicit render target
 450          * or depth stencil. The content may be destroyed, but we still have to tear down
 451          * opengl resources, so we cannot leave early.
 452          *
 453          * Put the surfaces into sysmem, and reset the content. The D3D content is undefined,
 454          * but we can't set the sysmem INDRAWABLE because when we're rendering the swapchain
 455          * or the depth stencil into an FBO the texture or render buffer will be removed
 456          * and all flags get lost
 457          */
 458         surface_init_sysmem(surface);
 459     }
 460     else
 461     {
 462         /* Load the surface into system memory */
 463         surface_load_location(surface, SFLAG_INSYSMEM, NULL);
 464         surface_modify_location(surface, SFLAG_INDRAWABLE, FALSE);
 465     }
 466     surface_modify_location(surface, SFLAG_INTEXTURE, FALSE);
 467     surface_modify_location(surface, SFLAG_INSRGBTEX, FALSE);
 468     surface->flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
 469
 470     context = context_acquire(device, NULL);
 471     gl_info = context->gl_info;
 472
 473     /* Destroy PBOs, but load them into real sysmem before */
 474     if (surface->flags & SFLAG_PBO)
 475         surface_remove_pbo(surface, gl_info);
 476
 477     /* Destroy fbo render buffers. This is needed for implicit render targets, for
 478      * all application-created targets the application has to release the surface
 479      * before calling _Reset
 480      */
 481     LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &surface->renderbuffers, renderbuffer_entry_t, entry)
 482     {
 483         ENTER_GL();
 484         gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
 485         LEAVE_GL();
 486         list_remove(&entry->entry);
 487         HeapFree(GetProcessHeap(), 0, entry);
 488     }
 489     list_init(&surface->renderbuffers);
 490     surface->current_renderbuffer = NULL;
 491
 492     /* If we're in a texture, the texture name belongs to the texture.
 493      * Otherwise, destroy it. */
 494     if (surface->container.type != WINED3D_CONTAINER_TEXTURE)
 495     {
 496         ENTER_GL();
 497         glDeleteTextures(1, &surface->texture_name);
 498         surface->texture_name = 0;
 499         glDeleteTextures(1, &surface->texture_name_srgb);
 500         surface->texture_name_srgb = 0;
 501         LEAVE_GL();
 502     }
 503
 504     context_release(context);
 505
 506     resource_unload(resource);
 507 }
 508
 509 static const struct wined3d_resource_ops surface_resource_ops =
 510 {
 511     surface_unload,
 512 };
 513
 514 static const struct wined3d_surface_ops surface_ops =
 515 {
 516     surface_realize_palette,
 517     surface_draw_overlay,
 518 };
 519
 520 HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
 521         UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
 522         UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id,
 523         WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops)
 524 {
 525     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
 526     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id);
 527     void (*cleanup)(IWineD3DSurfaceImpl *This);
 528     unsigned int resource_size;
 529     HRESULT hr;
 530
 531     if (multisample_quality > 0)
 532     {
 533         FIXME("multisample_quality set to %u, substituting 0\n", multisample_quality);
 534         multisample_quality = 0;
 535     }
 536
 537     /* Quick lockable sanity check.
 538      * TODO: remove this after surfaces, usage and lockability have been debugged properly
 539      * this function is too deep to need to care about things like this.
 540      * Levels need to be checked too, since they all affect what can be done. */
 541     switch (pool)
 542     {
 543         case WINED3DPOOL_SCRATCH:
 544             if(!lockable)
 545             {
 546                 FIXME("Called with a pool of SCRATCH and a lockable of FALSE "
 547                         "which are mutually exclusive, setting lockable to TRUE.\n");
 548                 lockable = TRUE;
 549             }
 550             break;
 551
 552         case WINED3DPOOL_SYSTEMMEM:
 553             if (!lockable)
 554                 FIXME("Called with a pool of SYSTEMMEM and a lockable of FALSE, this is acceptable but unexpected.\n");
 555             break;
 556
 557         case WINED3DPOOL_MANAGED:
 558             if (usage & WINED3DUSAGE_DYNAMIC)
 559                 FIXME("Called with a pool of MANAGED and a usage of DYNAMIC which are mutually exclusive.\n");
 560             break;
 561
 562         case WINED3DPOOL_DEFAULT:
 563             if (lockable && !(usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL)))
 564                 WARN("Creating a lockable surface with a POOL of DEFAULT, that doesn't specify DYNAMIC usage.\n");
 565             break;
 566
 567         default:
 568             FIXME("Unknown pool %#x.\n", pool);
 569             break;
 570     };
 571
 572     if (usage & WINED3DUSAGE_RENDERTARGET && pool != WINED3DPOOL_DEFAULT)
 573     {
 574         FIXME("Trying to create a render target that isn't in the default pool.\n");
 575     }
 576
 577     /* FIXME: Check that the format is supported by the device. */
 578
 579     resource_size = wined3d_format_calculate_size(format, alignment, width, height);
 580     if (!resource_size) return WINED3DERR_INVALIDCALL;
 581
 582     /* Look at the implementation and set the correct Vtable. */
 583     switch (surface_type)
 584     {
 585         case SURFACE_OPENGL:
 586             surface->lpVtbl = &IWineD3DSurface_Vtbl;
 587             cleanup = surface_cleanup;
 588             break;
 589
 590         case SURFACE_GDI:
 591             surface->lpVtbl = &IWineGDISurface_Vtbl;
 592             cleanup = surface_gdi_cleanup;
 593             break;
 594
 595         default:
 596             ERR("Requested unknown surface implementation %#x.\n", surface_type);
 597             return WINED3DERR_INVALIDCALL;
 598     }
 599
 600     hr = resource_init(&surface->resource, device, WINED3DRTYPE_SURFACE, format,
 601             multisample_type, multisample_quality, usage, pool, width, height, 1,
 602             resource_size, parent, parent_ops, &surface_resource_ops);
 603     if (FAILED(hr))
 604     {
 605         WARN("Failed to initialize resource, returning %#x.\n", hr);
 606         return hr;
 607     }
 608
 609     /* "Standalone" surface. */
 610     surface_set_container(surface, WINED3D_CONTAINER_NONE, NULL);
 611
 612     surface->texture_level = level;
 613     list_init(&surface->overlays);
 614
 615     /* Flags */
 616     surface->flags = SFLAG_NORMCOORD; /* Default to normalized coords. */
 617     if (discard) surface->flags |= SFLAG_DISCARD;
 618     if (lockable || format_id == WINED3DFMT_D16_LOCKABLE) surface->flags |= SFLAG_LOCKABLE;
 619
 620     /* Mark the texture as dirty so that it gets loaded first time around. */
 621     surface_add_dirty_rect(surface, NULL);
 622     list_init(&surface->renderbuffers);
 623
 624     TRACE("surface %p, memory %p, size %u\n", surface, surface->resource.allocatedMemory, surface->resource.size);
 625
 626     /* Call the private setup routine */
 627     hr = IWineD3DSurface_PrivateSetup((IWineD3DSurface *)surface);
 628     if (FAILED(hr))
 629     {
 630         ERR("Private setup failed, returning %#x\n", hr);
 631         cleanup(surface);
 632         return hr;
 633     }
 634
 635     return hr;
 636 }
 637
 638 static void surface_force_reload(IWineD3DSurfaceImpl *surface)
 639 {
 640     surface->flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
 641 }
 642
 643 void surface_set_texture_name(IWineD3DSurfaceImpl *surface, GLuint new_name, BOOL srgb)
 644 {
 645     GLuint *name;
 646     DWORD flag;
 647
 648     TRACE("surface %p, new_name %u, srgb %#x.\n", surface, new_name, srgb);
 649
 650     if(srgb)
 651     {
 652         name = &surface->texture_name_srgb;
 653         flag = SFLAG_INSRGBTEX;
 654     }
 655     else
 656     {
 657         name = &surface->texture_name;
 658         flag = SFLAG_INTEXTURE;
 659     }
 660
 661     if (!*name && new_name)
 662     {
 663         /* FIXME: We shouldn't need to remove SFLAG_INTEXTURE if the
 664          * surface has no texture name yet. See if we can get rid of this. */
 665         if (surface->flags & flag)
 666             ERR("Surface has %s set, but no texture name.\n", debug_surflocation(flag));
 667         surface_modify_location(surface, flag, FALSE);
 668     }
 669
 670     *name = new_name;
 671     surface_force_reload(surface);
 672 }
 673
 674 void surface_set_texture_target(IWineD3DSurfaceImpl *surface, GLenum target)
 675 {
 676     TRACE("surface %p, target %#x.\n", surface, target);
 677
 678     if (surface->texture_target != target)
 679     {
 680         if (target == GL_TEXTURE_RECTANGLE_ARB)
 681         {
 682             surface->flags &= ~SFLAG_NORMCOORD;
 683         }
 684         else if (surface->texture_target == GL_TEXTURE_RECTANGLE_ARB)
 685         {
 686             surface->flags |= SFLAG_NORMCOORD;
 687         }
 688     }
 689     surface->texture_target = target;
 690     surface_force_reload(surface);
 691 }
 692
 693 /* Context activation is done by the caller. */
 694 void surface_bind(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info, BOOL srgb)
 695 {
 696     TRACE("surface %p, gl_info %p, srgb %#x.\n", surface, gl_info, srgb);
 697
 698     if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
 699     {
 700         struct wined3d_texture *texture = surface->container.u.texture;
 701
 702         TRACE("Passing to container (%p).\n", texture);
 703         texture->texture_ops->texture_bind(texture, gl_info, srgb);
 704     }
 705     else
 706     {
 707         if (surface->texture_level)
 708         {
 709             ERR("Standalone surface %p is non-zero texture level %u.\n",
 710                     surface, surface->texture_level);
 711         }
 712
 713         if (srgb)
 714             ERR("Trying to bind standalone surface %p as sRGB.\n", surface);
 715
 716         ENTER_GL();
 717
 718         if (!surface->texture_name)
 719         {
 720             glGenTextures(1, &surface->texture_name);
 721             checkGLcall("glGenTextures");
 722
 723             TRACE("Surface %p given name %u.\n", surface, surface->texture_name);
 724
 725             glBindTexture(surface->texture_target, surface->texture_name);
 726             checkGLcall("glBindTexture");
 727             glTexParameteri(surface->texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 728             glTexParameteri(surface->texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 729             glTexParameteri(surface->texture_target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 730             glTexParameteri(surface->texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 731             glTexParameteri(surface->texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 732             checkGLcall("glTexParameteri");
 733         }
 734         else
 735         {
 736             glBindTexture(surface->texture_target, surface->texture_name);
 737             checkGLcall("glBindTexture");
 738         }
 739
 740         LEAVE_GL();
 741     }
 742 }
 743
 744 /* Context activation is done by the caller. */
 745 static void surface_bind_and_dirtify(IWineD3DSurfaceImpl *surface,
 746         const struct wined3d_gl_info *gl_info, BOOL srgb)
 747 {
 748     IWineD3DDeviceImpl *device = surface->resource.device;
 749     DWORD active_sampler;
 750
 751     /* We don't need a specific texture unit, but after binding the texture the current unit is dirty.
 752      * Read the unit back instead of switching to 0, this avoids messing around with the state manager's
 753      * gl states. The current texture unit should always be a valid one.
 754      *
 755      * To be more specific, this is tricky because we can implicitly be called
 756      * from sampler() in state.c. This means we can't touch anything other than
 757      * whatever happens to be the currently active texture, or we would risk
 758      * marking already applied sampler states dirty again.
 759      *
 760      * TODO: Track the current active texture per GL context instead of using glGet
 761      */
 762     GLint active_texture;
 763     ENTER_GL();
 764     glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
 765     LEAVE_GL();
 766     active_sampler = device->rev_tex_unit_map[active_texture - GL_TEXTURE0_ARB];
 767
 768     if (active_sampler != WINED3D_UNMAPPED_STAGE)
 769     {
 770         IWineD3DDeviceImpl_MarkStateDirty(device, STATE_SAMPLER(active_sampler));
 771     }
 772     surface_bind(surface, gl_info, srgb);
 773 }
 774
 775 /* This function checks if the primary render target uses the 8bit paletted format. */
 776 static BOOL primary_render_target_is_p8(IWineD3DDeviceImpl *device)
 777 {
 778     if (device->render_targets && device->render_targets[0])
 779     {
 780         IWineD3DSurfaceImpl *render_target = device->render_targets[0];
 781         if ((render_target->resource.usage & WINED3DUSAGE_RENDERTARGET)
 782                 && (render_target->resource.format->id == WINED3DFMT_P8_UINT))
 783             return TRUE;
 784     }
 785     return FALSE;
 786 }
 787
 788 /* This call just downloads data, the caller is responsible for binding the
 789  * correct texture. */
 790 /* Context activation is done by the caller. */
 791 static void surface_download_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info)
 792 {
 793     const struct wined3d_format *format = This->resource.format;
 794
 795     /* Only support read back of converted P8 surfaces */
 796     if (This->flags & SFLAG_CONVERTED && format->id != WINED3DFMT_P8_UINT)
 797     {
 798         FIXME("Readback conversion not supported for format %s.\n", debug_d3dformat(format->id));
 799         return;
 800     }
 801
 802     ENTER_GL();
 803
 804     if (format->flags & WINED3DFMT_FLAG_COMPRESSED)
 805     {
 806         TRACE("(%p) : Calling glGetCompressedTexImageARB level %d, format %#x, type %#x, data %p.\n",
 807                 This, This->texture_level, format->glFormat, format->glType,
 808                 This->resource.allocatedMemory);
 809
 810         if (This->flags & SFLAG_PBO)
 811         {
 812             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 813             checkGLcall("glBindBufferARB");
 814             GL_EXTCALL(glGetCompressedTexImageARB(This->texture_target, This->texture_level, NULL));
 815             checkGLcall("glGetCompressedTexImageARB");
 816             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 817             checkGLcall("glBindBufferARB");
 818         }
 819         else
 820         {
 821             GL_EXTCALL(glGetCompressedTexImageARB(This->texture_target,
 822                     This->texture_level, This->resource.allocatedMemory));
 823             checkGLcall("glGetCompressedTexImageARB");
 824         }
 825
 826         LEAVE_GL();
 827     } else {
 828         void *mem;
 829         GLenum gl_format = format->glFormat;
 830         GLenum gl_type = format->glType;
 831         int src_pitch = 0;
 832         int dst_pitch = 0;
 833
 834         /* In case of P8 the index is stored in the alpha component if the primary render target uses P8 */
 835         if (format->id == WINED3DFMT_P8_UINT && primary_render_target_is_p8(This->resource.device))
 836         {
 837             gl_format = GL_ALPHA;
 838             gl_type = GL_UNSIGNED_BYTE;
 839         }
 840
 841         if (This->flags & SFLAG_NONPOW2)
 842         {
 843             unsigned char alignment = This->resource.device->surface_alignment;
 844             src_pitch = format->byte_count * This->pow2Width;
 845             dst_pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *) This);
 846             src_pitch = (src_pitch + alignment - 1) & ~(alignment - 1);
 847             mem = HeapAlloc(GetProcessHeap(), 0, src_pitch * This->pow2Height);
 848         } else {
 849             mem = This->resource.allocatedMemory;
 850         }
 851
 852         TRACE("(%p) : Calling glGetTexImage level %d, format %#x, type %#x, data %p\n",
 853                 This, This->texture_level, gl_format, gl_type, mem);
 854
 855         if (This->flags & SFLAG_PBO)
 856         {
 857             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
 858             checkGLcall("glBindBufferARB");
 859
 860             glGetTexImage(This->texture_target, This->texture_level, gl_format, gl_type, NULL);
 861             checkGLcall("glGetTexImage");
 862
 863             GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
 864             checkGLcall("glBindBufferARB");
 865         } else {
 866             glGetTexImage(This->texture_target, This->texture_level, gl_format, gl_type, mem);
 867             checkGLcall("glGetTexImage");
 868         }
 869         LEAVE_GL();
 870
 871         if (This->flags & SFLAG_NONPOW2)
 872         {
 873             const BYTE *src_data;
 874             BYTE *dst_data;
 875             UINT y;
 876             /*
 877              * Some games (e.g. warhammer 40k) don't work properly with the odd pitches, preventing
 878              * the surface pitch from being used to box non-power2 textures. Instead we have to use a hack to
 879              * repack the texture so that the bpp * width pitch can be used instead of bpp * pow2width.
 880              *
 881              * We're doing this...
 882              *
 883              * instead of boxing the texture :
 884              * |<-texture width ->|  -->pow2width|   /\
 885              * |111111111111111111|              |   |
 886              * |222 Texture 222222| boxed empty  | texture height
 887              * |3333 Data 33333333|              |   |
 888              * |444444444444444444|              |   \/
 889              * -----------------------------------   |
 890              * |     boxed  empty | boxed empty  | pow2height
 891              * |                  |              |   \/
 892              * -----------------------------------
 893              *
 894              *
 895              * we're repacking the data to the expected texture width
 896              *
 897              * |<-texture width ->|  -->pow2width|   /\
 898              * |111111111111111111222222222222222|   |
 899              * |222333333333333333333444444444444| texture height
 900              * |444444                           |   |
 901              * |                                 |   \/
 902              * |                                 |   |
 903              * |            empty                | pow2height
 904              * |                                 |   \/
 905              * -----------------------------------
 906              *
 907              * == is the same as
 908              *
 909              * |<-texture width ->|    /\
 910              * |111111111111111111|
 911              * |222222222222222222|texture height
 912              * |333333333333333333|
 913              * |444444444444444444|    \/
 914              * --------------------
 915              *
 916              * this also means that any references to allocatedMemory should work with the data as if were a
 917              * standard texture with a non-power2 width instead of texture boxed up to be a power2 texture.
 918              *
 919              * internally the texture is still stored in a boxed format so any references to textureName will
 920              * get a boxed texture with width pow2width and not a texture of width resource.width.
 921              *
 922              * Performance should not be an issue, because applications normally do not lock the surfaces when
 923              * rendering. If an app does, the SFLAG_DYNLOCK flag will kick in and the memory copy won't be released,
 924              * and doesn't have to be re-read.
 925              */
 926             src_data = mem;
 927             dst_data = This->resource.allocatedMemory;
 928             TRACE("(%p) : Repacking the surface data from pitch %d to pitch %d\n", This, src_pitch, dst_pitch);
 929             for (y = 1; y < This->resource.height; ++y)
 930             {
 931                 /* skip the first row */
 932                 src_data += src_pitch;
 933                 dst_data += dst_pitch;
 934                 memcpy(dst_data, src_data, dst_pitch);
 935             }
 936
 937             HeapFree(GetProcessHeap(), 0, mem);
 938         }
 939     }
 940
 941     /* Surface has now been downloaded */
 942     This->flags |= SFLAG_INSYSMEM;
 943 }
 944
 945 /* This call just uploads data, the caller is responsible for binding the
 946  * correct texture. */
 947 /* Context activation is done by the caller. */
 948 static void surface_upload_data(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
 949         const struct wined3d_format *format, BOOL srgb, const GLvoid *data)
 950 {
 951     GLsizei width = This->resource.width;
 952     GLsizei height = This->resource.height;
 953     GLenum internal;
 954
 955     if (srgb)
 956     {
 957         internal = format->glGammaInternal;
 958     }
 959     else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET && surface_is_offscreen(This))
 960     {
 961         internal = format->rtInternal;
 962     }
 963     else
 964     {
 965         internal = format->glInternal;
 966     }
 967
 968     TRACE("This %p, internal %#x, width %d, height %d, format %#x, type %#x, data %p.\n",
 969             This, internal, width, height, format->glFormat, format->glType, data);
 970     TRACE("target %#x, level %u, resource size %u.\n",
 971             This->texture_target, This->texture_level, This->resource.size);
 972
 973     if (format->heightscale != 1.0f && format->heightscale != 0.0f) height *= format->heightscale;
 974
 975     ENTER_GL();
 976
 977     if (This->flags & SFLAG_PBO)
 978     {
 979         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
 980         checkGLcall("glBindBufferARB");
 981
 982         TRACE("(%p) pbo: %#x, data: %p.\n", This, This->pbo, data);
 983         data = NULL;
 984     }
 985
 986     if (format->flags & WINED3DFMT_FLAG_COMPRESSED)
 987     {
 988         TRACE("Calling glCompressedTexSubImage2DARB.\n");
 989
 990         GL_EXTCALL(glCompressedTexSubImage2DARB(This->texture_target, This->texture_level,
 991                 0, 0, width, height, internal, This->resource.size, data));
 992         checkGLcall("glCompressedTexSubImage2DARB");
 993     }
 994     else
 995     {
 996         TRACE("Calling glTexSubImage2D.\n");
 997
 998         glTexSubImage2D(This->texture_target, This->texture_level,
 999                 0, 0, width, height, format->glFormat, format->glType, data);
1000         checkGLcall("glTexSubImage2D");
1001     }
1002
1003     if (This->flags & SFLAG_PBO)
1004     {
1005         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1006         checkGLcall("glBindBufferARB");
1007     }
1008
1009     LEAVE_GL();
1010
1011     if (gl_info->quirks & WINED3D_QUIRK_FBO_TEX_UPDATE)
1012     {
1013         IWineD3DDeviceImpl *device = This->resource.device;
1014         unsigned int i;
1015
1016         for (i = 0; i < device->context_count; ++i)
1017         {
1018             context_surface_update(device->contexts[i], This);
1019         }
1020     }
1021 }
1022
1023 /* This call just allocates the texture, the caller is responsible for binding
1024  * the correct texture. */
1025 /* Context activation is done by the caller. */
1026 static void surface_allocate_surface(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
1027         const struct wined3d_format *format, BOOL srgb)
1028 {
1029     BOOL enable_client_storage = FALSE;
1030     GLsizei width = This->pow2Width;
1031     GLsizei height = This->pow2Height;
1032     const BYTE *mem = NULL;
1033     GLenum internal;
1034
1035     if (srgb)
1036     {
1037         internal = format->glGammaInternal;
1038     }
1039     else if (This->resource.usage & WINED3DUSAGE_RENDERTARGET && surface_is_offscreen(This))
1040     {
1041         internal = format->rtInternal;
1042     }
1043     else
1044     {
1045         internal = format->glInternal;
1046     }
1047
1048     if (format->heightscale != 1.0f && format->heightscale != 0.0f) height *= format->heightscale;
1049
1050     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",
1051             This, This->texture_target, This->texture_level, debug_d3dformat(format->id),
1052             internal, width, height, format->glFormat, format->glType);
1053
1054     ENTER_GL();
1055
1056     if (gl_info->supported[APPLE_CLIENT_STORAGE])
1057     {
1058         if (This->flags & (SFLAG_NONPOW2 | SFLAG_DIBSECTION | SFLAG_CONVERTED)
1059                 || !This->resource.allocatedMemory)
1060         {
1061             /* In some cases we want to disable client storage.
1062              * SFLAG_NONPOW2 has a bigger opengl texture than the client memory, and different pitches
1063              * SFLAG_DIBSECTION: Dibsections may have read / write protections on the memory. Avoid issues...
1064              * SFLAG_CONVERTED: The conversion destination memory is freed after loading the surface
1065              * allocatedMemory == NULL: Not defined in the extension. Seems to disable client storage effectively
1066              */
1067             glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
1068             checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE)");
1069             This->flags &= ~SFLAG_CLIENT;
1070             enable_client_storage = TRUE;
1071         }
1072         else
1073         {
1074             This->flags |= SFLAG_CLIENT;
1075
1076             /* Point opengl to our allocated texture memory. Do not use resource.allocatedMemory here because
1077              * it might point into a pbo. Instead use heapMemory, but get the alignment right.
1078              */
1079             mem = (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1080         }
1081     }
1082
1083     if (format->flags & WINED3DFMT_FLAG_COMPRESSED && mem)
1084     {
1085         GL_EXTCALL(glCompressedTexImage2DARB(This->texture_target, This->texture_level,
1086                 internal, width, height, 0, This->resource.size, mem));
1087         checkGLcall("glCompressedTexImage2DARB");
1088     }
1089     else
1090     {
1091         glTexImage2D(This->texture_target, This->texture_level,
1092                 internal, width, height, 0, format->glFormat, format->glType, mem);
1093         checkGLcall("glTexImage2D");
1094     }
1095
1096     if(enable_client_storage) {
1097         glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
1098         checkGLcall("glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE)");
1099     }
1100     LEAVE_GL();
1101 }
1102
1103 /* In D3D the depth stencil dimensions have to be greater than or equal to the
1104  * render target dimensions. With FBOs, the dimensions have to be an exact match. */
1105 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
1106 /* GL locking is done by the caller */
1107 void surface_set_compatible_renderbuffer(IWineD3DSurfaceImpl *surface, IWineD3DSurfaceImpl *rt)
1108 {
1109     const struct wined3d_gl_info *gl_info = &surface->resource.device->adapter->gl_info;
1110     renderbuffer_entry_t *entry;
1111     GLuint renderbuffer = 0;
1112     unsigned int src_width, src_height;
1113     unsigned int width, height;
1114
1115     if (rt && rt->resource.format->id != WINED3DFMT_NULL)
1116     {
1117         width = rt->pow2Width;
1118         height = rt->pow2Height;
1119     }
1120     else
1121     {
1122         width = surface->pow2Width;
1123         height = surface->pow2Height;
1124     }
1125
1126     src_width = surface->pow2Width;
1127     src_height = surface->pow2Height;
1128
1129     /* A depth stencil smaller than the render target is not valid */
1130     if (width > src_width || height > src_height) return;
1131
1132     /* Remove any renderbuffer set if the sizes match */
1133     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]
1134             || (width == src_width && height == src_height))
1135     {
1136         surface->current_renderbuffer = NULL;
1137         return;
1138     }
1139
1140     /* Look if we've already got a renderbuffer of the correct dimensions */
1141     LIST_FOR_EACH_ENTRY(entry, &surface->renderbuffers, renderbuffer_entry_t, entry)
1142     {
1143         if (entry->width == width && entry->height == height)
1144         {
1145             renderbuffer = entry->id;
1146             surface->current_renderbuffer = entry;
1147             break;
1148         }
1149     }
1150
1151     if (!renderbuffer)
1152     {
1153         gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer);
1154         gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
1155         gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
1156                 surface->resource.format->glInternal, width, height);
1157
1158         entry = HeapAlloc(GetProcessHeap(), 0, sizeof(renderbuffer_entry_t));
1159         entry->width = width;
1160         entry->height = height;
1161         entry->id = renderbuffer;
1162         list_add_head(&surface->renderbuffers, &entry->entry);
1163
1164         surface->current_renderbuffer = entry;
1165     }
1166
1167     checkGLcall("set_compatible_renderbuffer");
1168 }
1169
1170 GLenum surface_get_gl_buffer(IWineD3DSurfaceImpl *surface)
1171 {
1172     IWineD3DSwapChainImpl *swapchain = surface->container.u.swapchain;
1173
1174     TRACE("surface %p.\n", surface);
1175
1176     if (surface->container.type != WINED3D_CONTAINER_SWAPCHAIN)
1177     {
1178         ERR("Surface %p is not on a swapchain.\n", surface);
1179         return GL_NONE;
1180     }
1181
1182     if (swapchain->back_buffers && swapchain->back_buffers[0] == surface)
1183     {
1184         if (swapchain->render_to_fbo)
1185         {
1186             TRACE("Returning GL_COLOR_ATTACHMENT0\n");
1187             return GL_COLOR_ATTACHMENT0;
1188         }
1189         TRACE("Returning GL_BACK\n");
1190         return GL_BACK;
1191     }
1192     else if (surface == swapchain->front_buffer)
1193     {
1194         TRACE("Returning GL_FRONT\n");
1195         return GL_FRONT;
1196     }
1197
1198     FIXME("Higher back buffer, returning GL_BACK\n");
1199     return GL_BACK;
1200 }
1201
1202 /* Slightly inefficient way to handle multiple dirty rects but it works :) */
1203 void surface_add_dirty_rect(IWineD3DSurfaceImpl *surface, const WINED3DBOX *dirty_rect)
1204 {
1205     TRACE("surface %p, dirty_rect %p.\n", surface, dirty_rect);
1206
1207     if (!(surface->flags & SFLAG_INSYSMEM) && (surface->flags & SFLAG_INTEXTURE))
1208         /* No partial locking for textures yet. */
1209         surface_load_location(surface, SFLAG_INSYSMEM, NULL);
1210
1211     surface_modify_location(surface, SFLAG_INSYSMEM, TRUE);
1212     if (dirty_rect)
1213     {
1214         surface->dirtyRect.left = min(surface->dirtyRect.left, dirty_rect->Left);
1215         surface->dirtyRect.top = min(surface->dirtyRect.top, dirty_rect->Top);
1216         surface->dirtyRect.right = max(surface->dirtyRect.right, dirty_rect->Right);
1217         surface->dirtyRect.bottom = max(surface->dirtyRect.bottom, dirty_rect->Bottom);
1218     }
1219     else
1220     {
1221         surface->dirtyRect.left = 0;
1222         surface->dirtyRect.top = 0;
1223         surface->dirtyRect.right = surface->resource.width;
1224         surface->dirtyRect.bottom = surface->resource.height;
1225     }
1226
1227     /* if the container is a texture then mark it dirty. */
1228     if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
1229     {
1230         TRACE("Passing to container.\n");
1231         wined3d_texture_set_dirty(surface->container.u.texture, TRUE);
1232     }
1233 }
1234
1235 static BOOL surface_convert_color_to_float(IWineD3DSurfaceImpl *surface, DWORD color, WINED3DCOLORVALUE *float_color)
1236 {
1237     const struct wined3d_format *format = surface->resource.format;
1238     IWineD3DDeviceImpl *device = surface->resource.device;
1239
1240     switch (format->id)
1241     {
1242         case WINED3DFMT_P8_UINT:
1243             if (surface->palette)
1244             {
1245                 float_color->r = surface->palette->palents[color].peRed / 255.0f;
1246                 float_color->g = surface->palette->palents[color].peGreen / 255.0f;
1247                 float_color->b = surface->palette->palents[color].peBlue / 255.0f;
1248             }
1249             else
1250             {
1251                 float_color->r = 0.0f;
1252                 float_color->g = 0.0f;
1253                 float_color->b = 0.0f;
1254             }
1255             float_color->a = primary_render_target_is_p8(device) ? color / 255.0f : 1.0f;
1256             break;
1257
1258         case WINED3DFMT_B5G6R5_UNORM:
1259             float_color->r = ((color >> 11) & 0x1f) / 31.0f;
1260             float_color->g = ((color >> 5) & 0x3f) / 63.0f;
1261             float_color->b = (color & 0x1f) / 31.0f;
1262             float_color->a = 1.0f;
1263             break;
1264
1265         case WINED3DFMT_B8G8R8_UNORM:
1266         case WINED3DFMT_B8G8R8X8_UNORM:
1267             float_color->r = D3DCOLOR_R(color);
1268             float_color->g = D3DCOLOR_G(color);
1269             float_color->b = D3DCOLOR_B(color);
1270             float_color->a = 1.0f;
1271             break;
1272
1273         case WINED3DFMT_B8G8R8A8_UNORM:
1274             float_color->r = D3DCOLOR_R(color);
1275             float_color->g = D3DCOLOR_G(color);
1276             float_color->b = D3DCOLOR_B(color);
1277             float_color->a = D3DCOLOR_A(color);
1278             break;
1279
1280         default:
1281             ERR("Unhandled conversion from %s to floating point.\n", debug_d3dformat(format->id));
1282             return FALSE;
1283     }
1284
1285     return TRUE;
1286 }
1287
1288 static BOOL surface_convert_depth_to_float(IWineD3DSurfaceImpl *surface, DWORD depth, float *float_depth)
1289 {
1290     const struct wined3d_format *format = surface->resource.format;
1291
1292     switch (format->id)
1293     {
1294         case WINED3DFMT_S1_UINT_D15_UNORM:
1295             *float_depth = depth / (float)0x00007fff;
1296             break;
1297
1298         case WINED3DFMT_D16_UNORM:
1299             *float_depth = depth / (float)0x0000ffff;
1300             break;
1301
1302         case WINED3DFMT_D24_UNORM_S8_UINT:
1303         case WINED3DFMT_X8D24_UNORM:
1304             *float_depth = depth / (float)0x00ffffff;
1305             break;
1306
1307         case WINED3DFMT_D32_UNORM:
1308             *float_depth = depth / (float)0xffffffff;
1309             break;
1310
1311         default:
1312             ERR("Unhandled conversion from %s to floating point.\n", debug_d3dformat(format->id));
1313             return FALSE;
1314     }
1315
1316     return TRUE;
1317 }
1318
1319 static void surface_evict_sysmem(IWineD3DSurfaceImpl *surface)
1320 {
1321     if (surface->flags & SFLAG_DONOTFREE)
1322         return;
1323
1324     HeapFree(GetProcessHeap(), 0, surface->resource.heapMemory);
1325     surface->resource.allocatedMemory = NULL;
1326     surface->resource.heapMemory = NULL;
1327     surface_modify_location(surface, SFLAG_INSYSMEM, FALSE);
1328 }
1329
1330 HRESULT surface_load(IWineD3DSurfaceImpl *surface, BOOL srgb)
1331 {
1332     DWORD flag = srgb ? SFLAG_INSRGBTEX : SFLAG_INTEXTURE;
1333
1334     TRACE("surface %p, srgb %#x.\n", surface, srgb);
1335
1336     if (surface->resource.pool == WINED3DPOOL_SCRATCH)
1337     {
1338         ERR("Not supported on scratch surfaces.\n");
1339         return WINED3DERR_INVALIDCALL;
1340     }
1341
1342     if (!(surface->flags & flag))
1343     {
1344         TRACE("Reloading because surface is dirty\n");
1345     }
1346     /* Reload if either the texture and sysmem have different ideas about the
1347      * color key, or the actual key values changed. */
1348     else if (!(surface->flags & SFLAG_GLCKEY) != !(surface->CKeyFlags & WINEDDSD_CKSRCBLT)
1349             || ((surface->CKeyFlags & WINEDDSD_CKSRCBLT)
1350             && (surface->glCKey.dwColorSpaceLowValue != surface->SrcBltCKey.dwColorSpaceLowValue
1351             || surface->glCKey.dwColorSpaceHighValue != surface->SrcBltCKey.dwColorSpaceHighValue)))
1352     {
1353         TRACE("Reloading because of color keying\n");
1354         /* To perform the color key conversion we need a sysmem copy of
1355          * the surface. Make sure we have it. */
1356
1357         surface_load_location(surface, SFLAG_INSYSMEM, NULL);
1358         /* Make sure the texture is reloaded because of the color key change,
1359          * this kills performance though :( */
1360         /* TODO: This is not necessarily needed with hw palettized texture support. */
1361         surface_modify_location(surface, SFLAG_INSYSMEM, TRUE);
1362     }
1363     else
1364     {
1365         TRACE("surface is already in texture\n");
1366         return WINED3D_OK;
1367     }
1368
1369     /* No partial locking for textures yet. */
1370     surface_load_location(surface, flag, NULL);
1371     surface_evict_sysmem(surface);
1372
1373     return WINED3D_OK;
1374 }
1375
1376 /* Do not call while under the GL lock. */
1377 static ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface)
1378 {
1379     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1380     ULONG ref = InterlockedDecrement(&This->resource.ref);
1381     TRACE("(%p) : Releasing from %d\n", This, ref + 1);
1382
1383     if (!ref)
1384     {
1385         surface_cleanup(This);
1386         This->resource.parent_ops->wined3d_object_destroyed(This->resource.parent);
1387
1388         TRACE("(%p) Released.\n", This);
1389         HeapFree(GetProcessHeap(), 0, This);
1390     }
1391
1392     return ref;
1393 }
1394
1395 /* ****************************************************
1396    IWineD3DSurface IWineD3DResource parts follow
1397    **************************************************** */
1398
1399 /* Do not call while under the GL lock. */
1400 void surface_internal_preload(IWineD3DSurfaceImpl *surface, enum WINED3DSRGB srgb)
1401 {
1402     IWineD3DDeviceImpl *device = surface->resource.device;
1403
1404     TRACE("iface %p, srgb %#x.\n", surface, srgb);
1405
1406     if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
1407     {
1408         struct wined3d_texture *texture = surface->container.u.texture;
1409
1410         TRACE("Passing to container (%p).\n", texture);
1411         texture->texture_ops->texture_preload(texture, srgb);
1412     }
1413     else
1414     {
1415         struct wined3d_context *context = NULL;
1416
1417         TRACE("(%p) : About to load surface\n", surface);
1418
1419         if (!device->isInDraw) context = context_acquire(device, NULL);
1420
1421         if (surface->resource.format->id == WINED3DFMT_P8_UINT
1422                 || surface->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
1423         {
1424             if (palette9_changed(surface))
1425             {
1426                 TRACE("Reloading surface because the d3d8/9 palette was changed\n");
1427                 /* TODO: This is not necessarily needed with hw palettized texture support */
1428                 surface_load_location(surface, SFLAG_INSYSMEM, NULL);
1429                 /* Make sure the texture is reloaded because of the palette change, this kills performance though :( */
1430                 surface_modify_location(surface, SFLAG_INTEXTURE, FALSE);
1431             }
1432         }
1433
1434         surface_load(surface, srgb == SRGB_SRGB ? TRUE : FALSE);
1435
1436         if (surface->resource.pool == WINED3DPOOL_DEFAULT)
1437         {
1438             /* Tell opengl to try and keep this texture in video ram (well mostly) */
1439             GLclampf tmp;
1440             tmp = 0.9f;
1441             ENTER_GL();
1442             glPrioritizeTextures(1, &surface->texture_name, &tmp);
1443             LEAVE_GL();
1444         }
1445
1446         if (context) context_release(context);
1447     }
1448 }
1449
1450 static void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface)
1451 {
1452     surface_internal_preload((IWineD3DSurfaceImpl *)iface, SRGB_ANY);
1453 }
1454
1455 BOOL surface_init_sysmem(IWineD3DSurfaceImpl *surface)
1456 {
1457     if (!surface->resource.allocatedMemory)
1458     {
1459         surface->resource.heapMemory = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1460                 surface->resource.size + RESOURCE_ALIGNMENT);
1461         if (!surface->resource.heapMemory)
1462         {
1463             ERR("Out of memory\n");
1464             return FALSE;
1465         }
1466         surface->resource.allocatedMemory =
1467             (BYTE *)(((ULONG_PTR)surface->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1468     }
1469     else
1470     {
1471         memset(surface->resource.allocatedMemory, 0, surface->resource.size);
1472     }
1473
1474     surface_modify_location(surface, SFLAG_INSYSMEM, TRUE);
1475
1476     return TRUE;
1477 }
1478
1479 /* ******************************************************
1480    IWineD3DSurface IWineD3DSurface parts follow
1481    ****************************************************** */
1482
1483 /* Read the framebuffer back into the surface */
1484 static void read_from_framebuffer(IWineD3DSurfaceImpl *This, const RECT *rect, void *dest, UINT pitch)
1485 {
1486     IWineD3DDeviceImpl *device = This->resource.device;
1487     const struct wined3d_gl_info *gl_info;
1488     struct wined3d_context *context;
1489     BYTE *mem;
1490     GLint fmt;
1491     GLint type;
1492     BYTE *row, *top, *bottom;
1493     int i;
1494     BOOL bpp;
1495     RECT local_rect;
1496     BOOL srcIsUpsideDown;
1497     GLint rowLen = 0;
1498     GLint skipPix = 0;
1499     GLint skipRow = 0;
1500
1501     if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
1502         static BOOL warned = FALSE;
1503         if(!warned) {
1504             ERR("The application tries to lock the render target, but render target locking is disabled\n");
1505             warned = TRUE;
1506         }
1507         return;
1508     }
1509
1510     context = context_acquire(device, This);
1511     context_apply_blit_state(context, device);
1512     gl_info = context->gl_info;
1513
1514     ENTER_GL();
1515
1516     /* Select the correct read buffer, and give some debug output.
1517      * There is no need to keep track of the current read buffer or reset it, every part of the code
1518      * that reads sets the read buffer as desired.
1519      */
1520     if (surface_is_offscreen(This))
1521     {
1522         /* Mapping the primary render target which is not on a swapchain.
1523          * Read from the back buffer. */
1524         TRACE("Mapping offscreen render target.\n");
1525         glReadBuffer(device->offscreenBuffer);
1526         srcIsUpsideDown = TRUE;
1527     }
1528     else
1529     {
1530         /* Onscreen surfaces are always part of a swapchain */
1531         GLenum buffer = surface_get_gl_buffer(This);
1532         TRACE("Mapping %#x buffer.\n", buffer);
1533         glReadBuffer(buffer);
1534         checkGLcall("glReadBuffer");
1535         srcIsUpsideDown = FALSE;
1536     }
1537
1538     /* TODO: Get rid of the extra rectangle comparison and construction of a full surface rectangle */
1539     if(!rect) {
1540         local_rect.left = 0;
1541         local_rect.top = 0;
1542         local_rect.right = This->resource.width;
1543         local_rect.bottom = This->resource.height;
1544     }
1545     else
1546     {
1547         local_rect = *rect;
1548     }
1549     /* TODO: Get rid of the extra GetPitch call, LockRect does that too. Cache the pitch */
1550
1551     switch (This->resource.format->id)
1552     {
1553         case WINED3DFMT_P8_UINT:
1554         {
1555             if (primary_render_target_is_p8(device))
1556             {
1557                 /* In case of P8 render targets the index is stored in the alpha component */
1558                 fmt = GL_ALPHA;
1559                 type = GL_UNSIGNED_BYTE;
1560                 mem = dest;
1561                 bpp = This->resource.format->byte_count;
1562             } else {
1563                 /* GL can't return palettized data, so read ARGB pixels into a
1564                  * separate block of memory and convert them into palettized format
1565                  * in software. Slow, but if the app means to use palettized render
1566                  * targets and locks it...
1567                  *
1568                  * Use GL_RGB, GL_UNSIGNED_BYTE to read the surface for performance reasons
1569                  * Don't use GL_BGR as in the WINED3DFMT_R8G8B8 case, instead watch out
1570                  * for the color channels when palettizing the colors.
1571                  */
1572                 fmt = GL_RGB;
1573                 type = GL_UNSIGNED_BYTE;
1574                 pitch *= 3;
1575                 mem = HeapAlloc(GetProcessHeap(), 0, This->resource.size * 3);
1576                 if(!mem) {
1577                     ERR("Out of memory\n");
1578                     LEAVE_GL();
1579                     return;
1580                 }
1581                 bpp = This->resource.format->byte_count * 3;
1582             }
1583         }
1584         break;
1585
1586         default:
1587             mem = dest;
1588             fmt = This->resource.format->glFormat;
1589             type = This->resource.format->glType;
1590             bpp = This->resource.format->byte_count;
1591     }
1592
1593     if (This->flags & SFLAG_PBO)
1594     {
1595         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, This->pbo));
1596         checkGLcall("glBindBufferARB");
1597         if (mem)
1598         {
1599             ERR("mem not null for pbo -- unexpected\n");
1600             mem = NULL;
1601         }
1602     }
1603
1604     /* Save old pixel store pack state */
1605     glGetIntegerv(GL_PACK_ROW_LENGTH, &rowLen);
1606     checkGLcall("glGetIntegerv");
1607     glGetIntegerv(GL_PACK_SKIP_PIXELS, &skipPix);
1608     checkGLcall("glGetIntegerv");
1609     glGetIntegerv(GL_PACK_SKIP_ROWS, &skipRow);
1610     checkGLcall("glGetIntegerv");
1611
1612     /* Setup pixel store pack state -- to glReadPixels into the correct place */
1613     glPixelStorei(GL_PACK_ROW_LENGTH, This->resource.width);
1614     checkGLcall("glPixelStorei");
1615     glPixelStorei(GL_PACK_SKIP_PIXELS, local_rect.left);
1616     checkGLcall("glPixelStorei");
1617     glPixelStorei(GL_PACK_SKIP_ROWS, local_rect.top);
1618     checkGLcall("glPixelStorei");
1619
1620     glReadPixels(local_rect.left, !srcIsUpsideDown ? (This->resource.height - local_rect.bottom) : local_rect.top,
1621                  local_rect.right - local_rect.left,
1622                  local_rect.bottom - local_rect.top,
1623                  fmt, type, mem);
1624     checkGLcall("glReadPixels");
1625
1626     /* Reset previous pixel store pack state */
1627     glPixelStorei(GL_PACK_ROW_LENGTH, rowLen);
1628     checkGLcall("glPixelStorei");
1629     glPixelStorei(GL_PACK_SKIP_PIXELS, skipPix);
1630     checkGLcall("glPixelStorei");
1631     glPixelStorei(GL_PACK_SKIP_ROWS, skipRow);
1632     checkGLcall("glPixelStorei");
1633
1634     if (This->flags & SFLAG_PBO)
1635     {
1636         GL_EXTCALL(glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0));
1637         checkGLcall("glBindBufferARB");
1638
1639         /* Check if we need to flip the image. If we need to flip use glMapBufferARB
1640          * to get a pointer to it and perform the flipping in software. This is a lot
1641          * faster than calling glReadPixels for each line. In case we want more speed
1642          * we should rerender it flipped in a FBO and read the data back from the FBO. */
1643         if(!srcIsUpsideDown) {
1644             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1645             checkGLcall("glBindBufferARB");
1646
1647             mem = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1648             checkGLcall("glMapBufferARB");
1649         }
1650     }
1651
1652     /* TODO: Merge this with the palettization loop below for P8 targets */
1653     if(!srcIsUpsideDown) {
1654         UINT len, off;
1655         /* glReadPixels returns the image upside down, and there is no way to prevent this.
1656             Flip the lines in software */
1657         len = (local_rect.right - local_rect.left) * bpp;
1658         off = local_rect.left * bpp;
1659
1660         row = HeapAlloc(GetProcessHeap(), 0, len);
1661         if(!row) {
1662             ERR("Out of memory\n");
1663             if (This->resource.format->id == WINED3DFMT_P8_UINT) HeapFree(GetProcessHeap(), 0, mem);
1664             LEAVE_GL();
1665             return;
1666         }
1667
1668         top = mem + pitch * local_rect.top;
1669         bottom = mem + pitch * (local_rect.bottom - 1);
1670         for(i = 0; i < (local_rect.bottom - local_rect.top) / 2; i++) {
1671             memcpy(row, top + off, len);
1672             memcpy(top + off, bottom + off, len);
1673             memcpy(bottom + off, row, len);
1674             top += pitch;
1675             bottom -= pitch;
1676         }
1677         HeapFree(GetProcessHeap(), 0, row);
1678
1679         /* Unmap the temp PBO buffer */
1680         if (This->flags & SFLAG_PBO)
1681         {
1682             GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
1683             GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1684         }
1685     }
1686
1687     LEAVE_GL();
1688     context_release(context);
1689
1690     /* For P8 textures we need to perform an inverse palette lookup. This is done by searching for a palette
1691      * index which matches the RGB value. Note this isn't guaranteed to work when there are multiple entries for
1692      * the same color but we have no choice.
1693      * In case of P8 render targets, the index is stored in the alpha component so no conversion is needed.
1694      */
1695     if (This->resource.format->id == WINED3DFMT_P8_UINT && !primary_render_target_is_p8(device))
1696     {
1697         const PALETTEENTRY *pal = NULL;
1698         DWORD width = pitch / 3;
1699         int x, y, c;
1700
1701         if(This->palette) {
1702             pal = This->palette->palents;
1703         } else {
1704             ERR("Palette is missing, cannot perform inverse palette lookup\n");
1705             HeapFree(GetProcessHeap(), 0, mem);
1706             return ;
1707         }
1708
1709         for(y = local_rect.top; y < local_rect.bottom; y++) {
1710             for(x = local_rect.left; x < local_rect.right; x++) {
1711                 /*                      start              lines            pixels      */
1712                 const BYTE *blue = mem + y * pitch + x * (sizeof(BYTE) * 3);
1713                 const BYTE *green = blue  + 1;
1714                 const BYTE *red = green + 1;
1715
1716                 for(c = 0; c < 256; c++) {
1717                     if(*red   == pal[c].peRed   &&
1718                        *green == pal[c].peGreen &&
1719                        *blue  == pal[c].peBlue)
1720                     {
1721                         *((BYTE *) dest + y * width + x) = c;
1722                         break;
1723                     }
1724                 }
1725             }
1726         }
1727         HeapFree(GetProcessHeap(), 0, mem);
1728     }
1729 }
1730
1731 /* Read the framebuffer contents into a texture */
1732 static void read_from_framebuffer_texture(IWineD3DSurfaceImpl *This, BOOL srgb)
1733 {
1734     IWineD3DDeviceImpl *device = This->resource.device;
1735     const struct wined3d_gl_info *gl_info;
1736     struct wined3d_context *context;
1737
1738     if (!surface_is_offscreen(This))
1739     {
1740         /* We would need to flip onscreen surfaces, but there's no efficient
1741          * way to do that here. It makes more sense for the caller to
1742          * explicitly go through sysmem. */
1743         ERR("Not supported for onscreen targets.\n");
1744         return;
1745     }
1746
1747     /* Activate the surface to read from. In some situations it isn't the currently active target(e.g. backbuffer
1748      * locking during offscreen rendering). RESOURCELOAD is ok because glCopyTexSubImage2D isn't affected by any
1749      * states in the stateblock, and no driver was found yet that had bugs in that regard.
1750      */
1751     context = context_acquire(device, This);
1752     gl_info = context->gl_info;
1753
1754     surface_prepare_texture(This, gl_info, srgb);
1755     surface_bind_and_dirtify(This, gl_info, srgb);
1756
1757     TRACE("Reading back offscreen render target %p.\n", This);
1758
1759     ENTER_GL();
1760
1761     glReadBuffer(device->offscreenBuffer);
1762     checkGLcall("glReadBuffer");
1763
1764     glCopyTexSubImage2D(This->texture_target, This->texture_level,
1765             0, 0, 0, 0, This->resource.width, This->resource.height);
1766     checkGLcall("glCopyTexSubImage2D");
1767
1768     LEAVE_GL();
1769
1770     context_release(context);
1771 }
1772
1773 /* Context activation is done by the caller. */
1774 static void surface_prepare_texture_internal(IWineD3DSurfaceImpl *surface,
1775         const struct wined3d_gl_info *gl_info, BOOL srgb)
1776 {
1777     DWORD alloc_flag = srgb ? SFLAG_SRGBALLOCATED : SFLAG_ALLOCATED;
1778     CONVERT_TYPES convert;
1779     struct wined3d_format format;
1780
1781     if (surface->flags & alloc_flag) return;
1782
1783     d3dfmt_get_conv(surface, TRUE, TRUE, &format, &convert);
1784     if (convert != NO_CONVERSION || format.convert) surface->flags |= SFLAG_CONVERTED;
1785     else surface->flags &= ~SFLAG_CONVERTED;
1786
1787     surface_bind_and_dirtify(surface, gl_info, srgb);
1788     surface_allocate_surface(surface, gl_info, &format, srgb);
1789     surface->flags |= alloc_flag;
1790 }
1791
1792 /* Context activation is done by the caller. */
1793 void surface_prepare_texture(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info, BOOL srgb)
1794 {
1795     if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
1796     {
1797         struct wined3d_texture *texture = surface->container.u.texture;
1798         UINT sub_count = texture->level_count * texture->layer_count;
1799         UINT i;
1800
1801         TRACE("surface %p is a subresource of texture %p.\n", surface, texture);
1802
1803         for (i = 0; i < sub_count; ++i)
1804         {
1805             IWineD3DSurfaceImpl *s = surface_from_resource(texture->sub_resources[i]);
1806             surface_prepare_texture_internal(s, gl_info, srgb);
1807         }
1808
1809         return;
1810     }
1811
1812     surface_prepare_texture_internal(surface, gl_info, srgb);
1813 }
1814
1815 static void surface_prepare_system_memory(IWineD3DSurfaceImpl *This)
1816 {
1817     IWineD3DDeviceImpl *device = This->resource.device;
1818     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1819
1820     /* Performance optimization: Count how often a surface is locked, if it is locked regularly do not throw away the system memory copy.
1821      * This avoids the need to download the surface from opengl all the time. The surface is still downloaded if the opengl texture is
1822      * changed
1823      */
1824     if (!(This->flags & SFLAG_DYNLOCK))
1825     {
1826         This->lockCount++;
1827         /* MAXLOCKCOUNT is defined in wined3d_private.h */
1828         if(This->lockCount > MAXLOCKCOUNT) {
1829             TRACE("Surface is locked regularly, not freeing the system memory copy any more\n");
1830             This->flags |= SFLAG_DYNLOCK;
1831         }
1832     }
1833
1834     /* Create a PBO for dynamically locked surfaces but don't do it for converted or non-pow2 surfaces.
1835      * Also don't create a PBO for systemmem surfaces.
1836      */
1837     if (gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] && (This->flags & SFLAG_DYNLOCK)
1838             && !(This->flags & (SFLAG_PBO | SFLAG_CONVERTED | SFLAG_NONPOW2))
1839             && (This->resource.pool != WINED3DPOOL_SYSTEMMEM))
1840     {
1841         GLenum error;
1842         struct wined3d_context *context;
1843
1844         context = context_acquire(device, NULL);
1845         ENTER_GL();
1846
1847         GL_EXTCALL(glGenBuffersARB(1, &This->pbo));
1848         error = glGetError();
1849         if (!This->pbo || error != GL_NO_ERROR)
1850             ERR("Failed to bind the PBO with error %s (%#x)\n", debug_glerror(error), error);
1851
1852         TRACE("Attaching pbo=%#x to (%p)\n", This->pbo, This);
1853
1854         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1855         checkGLcall("glBindBufferARB");
1856
1857         GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->resource.size + 4, This->resource.allocatedMemory, GL_STREAM_DRAW_ARB));
1858         checkGLcall("glBufferDataARB");
1859
1860         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1861         checkGLcall("glBindBufferARB");
1862
1863         /* We don't need the system memory anymore and we can't even use it for PBOs */
1864         if (!(This->flags & SFLAG_CLIENT))
1865         {
1866             HeapFree(GetProcessHeap(), 0, This->resource.heapMemory);
1867             This->resource.heapMemory = NULL;
1868         }
1869         This->resource.allocatedMemory = NULL;
1870         This->flags |= SFLAG_PBO;
1871         LEAVE_GL();
1872         context_release(context);
1873     }
1874     else if (!(This->resource.allocatedMemory || This->flags & SFLAG_PBO))
1875     {
1876         /* Whatever surface we have, make sure that there is memory allocated for the downloaded copy,
1877          * or a pbo to map
1878          */
1879         if(!This->resource.heapMemory) {
1880             This->resource.heapMemory = HeapAlloc(GetProcessHeap() ,0 , This->resource.size + RESOURCE_ALIGNMENT);
1881         }
1882         This->resource.allocatedMemory =
1883                 (BYTE *)(((ULONG_PTR) This->resource.heapMemory + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1));
1884         if (This->flags & SFLAG_INSYSMEM)
1885         {
1886             ERR("Surface without memory or pbo has SFLAG_INSYSMEM set!\n");
1887         }
1888     }
1889 }
1890
1891 static HRESULT WINAPI IWineD3DSurfaceImpl_Map(IWineD3DSurface *iface,
1892         WINED3DLOCKED_RECT *pLockedRect, const RECT *pRect, DWORD flags)
1893 {
1894     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
1895     IWineD3DDeviceImpl *device = This->resource.device;
1896     const RECT *pass_rect = pRect;
1897
1898     TRACE("iface %p, locked_rect %p, rect %s, flags %#x.\n",
1899             iface, pLockedRect, wine_dbgstr_rect(pRect), flags);
1900
1901     /* This is also done in the base class, but we have to verify this before loading any data from
1902      * gl into the sysmem copy. The PBO may be mapped, a different rectangle locked, the discard flag
1903      * may interfere, and all other bad things may happen
1904      */
1905     if (This->flags & SFLAG_LOCKED)
1906     {
1907         WARN("Surface is already locked, returning D3DERR_INVALIDCALL\n");
1908         return WINED3DERR_INVALIDCALL;
1909     }
1910     This->flags |= SFLAG_LOCKED;
1911
1912     if (!(This->flags & SFLAG_LOCKABLE))
1913     {
1914         TRACE("Warning: trying to lock unlockable surf@%p\n", This);
1915     }
1916
1917     if (flags & WINED3DLOCK_DISCARD)
1918     {
1919         TRACE("WINED3DLOCK_DISCARD flag passed, marking SYSMEM as up to date.\n");
1920         surface_prepare_system_memory(This);
1921         surface_modify_location(This, SFLAG_INSYSMEM, TRUE);
1922         goto lock_end;
1923     }
1924
1925     /* surface_load_location() does not check if the rectangle specifies
1926      * the full surface. Most callers don't need that, so do it here. */
1927     if (pRect && !pRect->top && !pRect->left
1928             && pRect->right == This->resource.width
1929             && pRect->bottom == This->resource.height)
1930     {
1931         pass_rect = NULL;
1932     }
1933
1934     if (!(wined3d_settings.rendertargetlock_mode == RTL_DISABLE
1935             && ((This->container.type == WINED3D_CONTAINER_SWAPCHAIN) || This == device->render_targets[0])))
1936     {
1937         surface_load_location(This, SFLAG_INSYSMEM, pass_rect);
1938     }
1939
1940 lock_end:
1941     if (This->flags & SFLAG_PBO)
1942     {
1943         const struct wined3d_gl_info *gl_info;
1944         struct wined3d_context *context;
1945
1946         context = context_acquire(device, NULL);
1947         gl_info = context->gl_info;
1948
1949         ENTER_GL();
1950         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
1951         checkGLcall("glBindBufferARB");
1952
1953         /* This shouldn't happen but could occur if some other function didn't handle the PBO properly */
1954         if(This->resource.allocatedMemory) {
1955             ERR("The surface already has PBO memory allocated!\n");
1956         }
1957
1958         This->resource.allocatedMemory = GL_EXTCALL(glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_READ_WRITE_ARB));
1959         checkGLcall("glMapBufferARB");
1960
1961         /* Make sure the pbo isn't set anymore in order not to break non-pbo calls */
1962         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
1963         checkGLcall("glBindBufferARB");
1964
1965         LEAVE_GL();
1966         context_release(context);
1967     }
1968
1969     if (!(flags & (WINED3DLOCK_NO_DIRTY_UPDATE | WINED3DLOCK_READONLY)))
1970     {
1971         if (!pRect)
1972             surface_add_dirty_rect(This, NULL);
1973         else
1974         {
1975             WINED3DBOX b;
1976
1977             b.Left = pRect->left;
1978             b.Top = pRect->top;
1979             b.Right = pRect->right;
1980             b.Bottom = pRect->bottom;
1981             b.Front = 0;
1982             b.Back = 1;
1983             surface_add_dirty_rect(This, &b);
1984         }
1985     }
1986
1987     return IWineD3DBaseSurfaceImpl_Map(iface, pLockedRect, pRect, flags);
1988 }
1989
1990 static void flush_to_framebuffer_drawpixels(IWineD3DSurfaceImpl *surface,
1991         const RECT *rect, GLenum fmt, GLenum type, UINT bpp, const BYTE *mem)
1992 {
1993     UINT pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *)surface);    /* target is argb, 4 byte */
1994     IWineD3DDeviceImpl *device = surface->resource.device;
1995     const struct wined3d_gl_info *gl_info;
1996     struct wined3d_context *context;
1997     RECT local_rect;
1998     UINT w, h;
1999
2000     surface_get_rect(surface, rect, &local_rect);
2001
2002     mem += local_rect.top * pitch + local_rect.left * bpp;
2003     w = local_rect.right - local_rect.left;
2004     h = local_rect.bottom - local_rect.top;
2005
2006     /* Activate the correct context for the render target */
2007     context = context_acquire(device, surface);
2008     context_apply_blit_state(context, device);
2009     gl_info = context->gl_info;
2010
2011     ENTER_GL();
2012
2013     if (!surface_is_offscreen(surface))
2014     {
2015         GLenum buffer = surface_get_gl_buffer(surface);
2016         TRACE("Unlocking %#x buffer.\n", buffer);
2017         context_set_draw_buffer(context, buffer);
2018
2019         surface_translate_drawable_coords(surface, context->win_handle, &local_rect);
2020         glPixelZoom(1.0f, -1.0f);
2021     }
2022     else
2023     {
2024         /* Primary offscreen render target */
2025         TRACE("Offscreen render target.\n");
2026         context_set_draw_buffer(context, device->offscreenBuffer);
2027
2028         glPixelZoom(1.0f, 1.0f);
2029     }
2030
2031     glRasterPos3i(local_rect.left, local_rect.top, 1);
2032     checkGLcall("glRasterPos3i");
2033
2034     /* If not fullscreen, we need to skip a number of bytes to find the next row of data */
2035     glPixelStorei(GL_UNPACK_ROW_LENGTH, surface->resource.width);
2036
2037     if (surface->flags & SFLAG_PBO)
2038     {
2039         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, surface->pbo));
2040         checkGLcall("glBindBufferARB");
2041     }
2042
2043     glDrawPixels(w, h, fmt, type, mem);
2044     checkGLcall("glDrawPixels");
2045
2046     if (surface->flags & SFLAG_PBO)
2047     {
2048         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
2049         checkGLcall("glBindBufferARB");
2050     }
2051
2052     glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
2053     checkGLcall("glPixelStorei(GL_UNPACK_ROW_LENGTH, 0)");
2054
2055     LEAVE_GL();
2056     context_release(context);
2057 }
2058
2059 static HRESULT WINAPI IWineD3DSurfaceImpl_Unmap(IWineD3DSurface *iface)
2060 {
2061     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2062     IWineD3DDeviceImpl *device = This->resource.device;
2063     BOOL fullsurface;
2064
2065     if (!(This->flags & SFLAG_LOCKED))
2066     {
2067         WARN("trying to Unlock an unlocked surf@%p\n", This);
2068         return WINEDDERR_NOTLOCKED;
2069     }
2070
2071     This->flags &= ~SFLAG_LOCKED;
2072     memset(&This->lockedRect, 0, sizeof(This->lockedRect));
2073
2074     if (This->flags & SFLAG_PBO)
2075     {
2076         const struct wined3d_gl_info *gl_info;
2077         struct wined3d_context *context;
2078
2079         TRACE("Freeing PBO memory\n");
2080
2081         context = context_acquire(device, NULL);
2082         gl_info = context->gl_info;
2083
2084         ENTER_GL();
2085         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, This->pbo));
2086         GL_EXTCALL(glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB));
2087         GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
2088         checkGLcall("glUnmapBufferARB");
2089         LEAVE_GL();
2090         context_release(context);
2091
2092         This->resource.allocatedMemory = NULL;
2093     }
2094
2095     TRACE("(%p) : dirtyfied(%d)\n", This, This->flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE) ? 0 : 1);
2096
2097     if (This->flags & (SFLAG_INDRAWABLE | SFLAG_INTEXTURE))
2098     {
2099         TRACE("(%p) : Not Dirtified so nothing to do, return now\n", This);
2100         goto unlock_end;
2101     }
2102
2103     if (This->container.type == WINED3D_CONTAINER_SWAPCHAIN
2104             || (device->render_targets && This == device->render_targets[0]))
2105     {
2106         if(wined3d_settings.rendertargetlock_mode == RTL_DISABLE) {
2107             static BOOL warned = FALSE;
2108             if(!warned) {
2109                 ERR("The application tries to write to the render target, but render target locking is disabled\n");
2110                 warned = TRUE;
2111             }
2112             goto unlock_end;
2113         }
2114
2115         if (!This->dirtyRect.left && !This->dirtyRect.top
2116                 && This->dirtyRect.right == This->resource.width
2117                 && This->dirtyRect.bottom == This->resource.height)
2118         {
2119             fullsurface = TRUE;
2120         } else {
2121             /* TODO: Proper partial rectangle tracking */
2122             fullsurface = FALSE;
2123             This->flags |= SFLAG_INSYSMEM;
2124         }
2125
2126         surface_load_location(This, SFLAG_INDRAWABLE, fullsurface ? NULL : &This->dirtyRect);
2127
2128         /* Partial rectangle tracking is not commonly implemented, it is only
2129          * done for render targets. INSYSMEM was set before to tell
2130          * surface_load_location() where to read the rectangle from.
2131          * Indrawable is set because all modifications from the partial
2132          * sysmem copy are written back to the drawable, thus the surface is
2133          * merged again in the drawable. The sysmem copy is not fully up to
2134          * date because only a subrectangle was read in Map(). */
2135         if (!fullsurface)
2136         {
2137             surface_modify_location(This, SFLAG_INDRAWABLE, TRUE);
2138             surface_evict_sysmem(This);
2139         }
2140
2141         This->dirtyRect.left   = This->resource.width;
2142         This->dirtyRect.top    = This->resource.height;
2143         This->dirtyRect.right  = 0;
2144         This->dirtyRect.bottom = 0;
2145     }
2146     else if (This->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2147     {
2148         FIXME("Depth Stencil buffer locking is not implemented\n");
2149     }
2150
2151 unlock_end:
2152     /* Overlays have to be redrawn manually after changes with the GL implementation */
2153     if (This->overlay_dest)
2154         This->surface_ops->surface_draw_overlay(This);
2155
2156     return WINED3D_OK;
2157 }
2158
2159 static void surface_release_client_storage(IWineD3DSurfaceImpl *surface)
2160 {
2161     struct wined3d_context *context;
2162
2163     context = context_acquire(surface->resource.device, NULL);
2164
2165     ENTER_GL();
2166     glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_FALSE);
2167     if (surface->texture_name)
2168     {
2169         surface_bind_and_dirtify(surface, context->gl_info, FALSE);
2170         glTexImage2D(surface->texture_target, surface->texture_level,
2171                 GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
2172     }
2173     if (surface->texture_name_srgb)
2174     {
2175         surface_bind_and_dirtify(surface, context->gl_info, TRUE);
2176         glTexImage2D(surface->texture_target, surface->texture_level,
2177                 GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
2178     }
2179     glPixelStorei(GL_UNPACK_CLIENT_STORAGE_APPLE, GL_TRUE);
2180
2181     LEAVE_GL();
2182     context_release(context);
2183
2184     surface_modify_location(surface, SFLAG_INSRGBTEX, FALSE);
2185     surface_modify_location(surface, SFLAG_INTEXTURE, FALSE);
2186     surface_force_reload(surface);
2187 }
2188
2189 static HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC)
2190 {
2191     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2192     WINED3DLOCKED_RECT lock;
2193     HRESULT hr;
2194     RGBQUAD col[256];
2195
2196     TRACE("(%p)->(%p)\n",This,pHDC);
2197
2198     if (This->flags & SFLAG_USERPTR)
2199     {
2200         ERR("Not supported on surfaces with an application-provided surfaces\n");
2201         return WINEDDERR_NODC;
2202     }
2203
2204     /* Give more detailed info for ddraw */
2205     if (This->flags & SFLAG_DCINUSE)
2206         return WINEDDERR_DCALREADYCREATED;
2207
2208     /* Can't GetDC if the surface is locked */
2209     if (This->flags & SFLAG_LOCKED)
2210         return WINED3DERR_INVALIDCALL;
2211
2212     memset(&lock, 0, sizeof(lock)); /* To be sure */
2213
2214     /* Create a DIB section if there isn't a hdc yet */
2215     if (!This->hDC)
2216     {
2217         if (This->flags & SFLAG_CLIENT)
2218         {
2219             surface_load_location(This, SFLAG_INSYSMEM, NULL);
2220             surface_release_client_storage(This);
2221         }
2222         hr = IWineD3DBaseSurfaceImpl_CreateDIBSection(iface);
2223         if(FAILED(hr)) return WINED3DERR_INVALIDCALL;
2224
2225         /* Use the dib section from now on if we are not using a PBO */
2226         if (!(This->flags & SFLAG_PBO))
2227             This->resource.allocatedMemory = This->dib.bitmap_data;
2228     }
2229
2230     /* Map the surface */
2231     hr = IWineD3DSurface_Map(iface, &lock, NULL, 0);
2232
2233     /* Sync the DIB with the PBO. This can't be done earlier because Map()
2234      * activates the allocatedMemory. */
2235     if (This->flags & SFLAG_PBO)
2236         memcpy(This->dib.bitmap_data, This->resource.allocatedMemory, This->dib.bitmap_size);
2237
2238     if (FAILED(hr))
2239     {
2240         ERR("IWineD3DSurface_Map failed, hr %#x.\n", hr);
2241         /* keep the dib section */
2242         return hr;
2243     }
2244
2245     if (This->resource.format->id == WINED3DFMT_P8_UINT
2246             || This->resource.format->id == WINED3DFMT_P8_UINT_A8_UNORM)
2247     {
2248         /* GetDC on palettized formats is unsupported in D3D9, and the method is missing in
2249             D3D8, so this should only be used for DX <=7 surfaces (with non-device palettes) */
2250         unsigned int n;
2251         const PALETTEENTRY *pal = NULL;
2252
2253         if(This->palette) {
2254             pal = This->palette->palents;
2255         } else {
2256             IWineD3DSurfaceImpl *dds_primary;
2257             IWineD3DSwapChainImpl *swapchain;
2258             swapchain = This->resource.device->swapchains[0];
2259             dds_primary = swapchain->front_buffer;
2260             if (dds_primary && dds_primary->palette)
2261                 pal = dds_primary->palette->palents;
2262         }
2263
2264         if (pal) {
2265             for (n=0; n<256; n++) {
2266                 col[n].rgbRed   = pal[n].peRed;
2267                 col[n].rgbGreen = pal[n].peGreen;
2268                 col[n].rgbBlue  = pal[n].peBlue;
2269                 col[n].rgbReserved = 0;
2270             }
2271             SetDIBColorTable(This->hDC, 0, 256, col);
2272         }
2273     }
2274
2275     *pHDC = This->hDC;
2276     TRACE("returning %p\n",*pHDC);
2277     This->flags |= SFLAG_DCINUSE;
2278
2279     return WINED3D_OK;
2280 }
2281
2282 static HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC)
2283 {
2284     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2285
2286     TRACE("(%p)->(%p)\n",This,hDC);
2287
2288     if (!(This->flags & SFLAG_DCINUSE))
2289         return WINEDDERR_NODC;
2290
2291     if (This->hDC !=hDC) {
2292         WARN("Application tries to release an invalid DC(%p), surface dc is %p\n", hDC, This->hDC);
2293         return WINEDDERR_NODC;
2294     }
2295
2296     if ((This->flags & SFLAG_PBO) && This->resource.allocatedMemory)
2297     {
2298         /* Copy the contents of the DIB over to the PBO */
2299         memcpy(This->resource.allocatedMemory, This->dib.bitmap_data, This->dib.bitmap_size);
2300     }
2301
2302     /* we locked first, so unlock now */
2303     IWineD3DSurface_Unmap(iface);
2304
2305     This->flags &= ~SFLAG_DCINUSE;
2306
2307     return WINED3D_OK;
2308 }
2309
2310 /* ******************************************************
2311    IWineD3DSurface Internal (No mapping to directx api) parts follow
2312    ****************************************************** */
2313
2314 HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck,
2315         BOOL use_texturing, struct wined3d_format *format, CONVERT_TYPES *convert)
2316 {
2317     BOOL colorkey_active = need_alpha_ck && (This->CKeyFlags & WINEDDSD_CKSRCBLT);
2318     IWineD3DDeviceImpl *device = This->resource.device;
2319     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2320     BOOL blit_supported = FALSE;
2321
2322     /* Copy the default values from the surface. Below we might perform fixups */
2323     /* TODO: get rid of color keying desc fixups by using e.g. a table. */
2324     *format = *This->resource.format;
2325     *convert = NO_CONVERSION;
2326
2327     /* Ok, now look if we have to do any conversion */
2328     switch (This->resource.format->id)
2329     {
2330         case WINED3DFMT_P8_UINT:
2331             /* Below the call to blit_supported is disabled for Wine 1.2
2332              * because the function isn't operating correctly yet. At the
2333              * moment 8-bit blits are handled in software and if certain GL
2334              * extensions are around, surface conversion is performed at
2335              * upload time. The blit_supported call recognizes it as a
2336              * destination fixup. This type of upload 'fixup' and 8-bit to
2337              * 8-bit blits need to be handled by the blit_shader.
2338              * TODO: get rid of this #if 0. */
2339 #if 0
2340             blit_supported = device->blitter->blit_supported(&device->adapter->gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
2341                     &rect, This->resource.usage, This->resource.pool, This->resource.format,
2342                     &rect, This->resource.usage, This->resource.pool, This->resource.format);
2343 #endif
2344             blit_supported = gl_info->supported[EXT_PALETTED_TEXTURE] || gl_info->supported[ARB_FRAGMENT_PROGRAM];
2345
2346             /* Use conversion when the blit_shader backend supports it. It only supports this in case of
2347              * texturing. Further also use conversion in case of color keying.
2348              * Paletted textures can be emulated using shaders but only do that for 2D purposes e.g. situations
2349              * in which the main render target uses p8. Some games like GTA Vice City use P8 for texturing which
2350              * conflicts with this.
2351              */
2352             if (!((blit_supported && device->render_targets && This == device->render_targets[0]))
2353                     || colorkey_active || !use_texturing)
2354             {
2355                 format->glFormat = GL_RGBA;
2356                 format->glInternal = GL_RGBA;
2357                 format->glType = GL_UNSIGNED_BYTE;
2358                 format->conv_byte_count = 4;
2359                 if (colorkey_active)
2360                     *convert = CONVERT_PALETTED_CK;
2361                 else
2362                     *convert = CONVERT_PALETTED;
2363             }
2364             break;
2365
2366         case WINED3DFMT_B2G3R3_UNORM:
2367             /* **********************
2368                 GL_UNSIGNED_BYTE_3_3_2
2369                 ********************** */
2370             if (colorkey_active) {
2371                 /* This texture format will never be used.. So do not care about color keying
2372                     up until the point in time it will be needed :-) */
2373                 FIXME(" ColorKeying not supported in the RGB 332 format !\n");
2374             }
2375             break;
2376
2377         case WINED3DFMT_B5G6R5_UNORM:
2378             if (colorkey_active)
2379             {
2380                 *convert = CONVERT_CK_565;
2381                 format->glFormat = GL_RGBA;
2382                 format->glInternal = GL_RGB5_A1;
2383                 format->glType = GL_UNSIGNED_SHORT_5_5_5_1;
2384                 format->conv_byte_count = 2;
2385             }
2386             break;
2387
2388         case WINED3DFMT_B5G5R5X1_UNORM:
2389             if (colorkey_active)
2390             {
2391                 *convert = CONVERT_CK_5551;
2392                 format->glFormat = GL_BGRA;
2393                 format->glInternal = GL_RGB5_A1;
2394                 format->glType = GL_UNSIGNED_SHORT_1_5_5_5_REV;
2395                 format->conv_byte_count = 2;
2396             }
2397             break;
2398
2399         case WINED3DFMT_B8G8R8_UNORM:
2400             if (colorkey_active)
2401             {
2402                 *convert = CONVERT_CK_RGB24;
2403                 format->glFormat = GL_RGBA;
2404                 format->glInternal = GL_RGBA8;
2405                 format->glType = GL_UNSIGNED_INT_8_8_8_8;
2406                 format->conv_byte_count = 4;
2407             }
2408             break;
2409
2410         case WINED3DFMT_B8G8R8X8_UNORM:
2411             if (colorkey_active)
2412             {
2413                 *convert = CONVERT_RGB32_888;
2414                 format->glFormat = GL_RGBA;
2415                 format->glInternal = GL_RGBA8;
2416                 format->glType = GL_UNSIGNED_INT_8_8_8_8;
2417                 format->conv_byte_count = 4;
2418             }
2419             break;
2420
2421         default:
2422             break;
2423     }
2424
2425     return WINED3D_OK;
2426 }
2427
2428 void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *This, BYTE table[256][4], BOOL colorkey)
2429 {
2430     IWineD3DDeviceImpl *device = This->resource.device;
2431     struct wined3d_palette *pal = This->palette;
2432     BOOL index_in_alpha = FALSE;
2433     unsigned int i;
2434
2435     /* Old games like StarCraft, C&C, Red Alert and others use P8 render targets.
2436      * Reading back the RGB output each lockrect (each frame as they lock the whole screen)
2437      * is slow. Further RGB->P8 conversion is not possible because palettes can have
2438      * duplicate entries. Store the color key in the unused alpha component to speed the
2439      * download up and to make conversion unneeded. */
2440     index_in_alpha = primary_render_target_is_p8(device);
2441
2442     if (!pal)
2443     {
2444         UINT dxVersion = device->wined3d->dxVersion;
2445
2446         /* In DirectDraw the palette is a property of the surface, there are no such things as device palettes. */
2447         if (dxVersion <= 7)
2448         {
2449             ERR("This code should never get entered for DirectDraw!, expect problems\n");
2450             if (index_in_alpha)
2451             {
2452                 /* Guarantees that memory representation remains correct after sysmem<->texture transfers even if
2453                  * there's no palette at this time. */
2454                 for (i = 0; i < 256; i++) table[i][3] = i;
2455             }
2456         }
2457         else
2458         {
2459             /* Direct3D >= 8 palette usage style: P8 textures use device palettes, palette entry format is A8R8G8B8,
2460              * alpha is stored in peFlags and may be used by the app if D3DPTEXTURECAPS_ALPHAPALETTE device
2461              * capability flag is present (wine does advertise this capability) */
2462             for (i = 0; i < 256; ++i)
2463             {
2464                 table[i][0] = device->palettes[device->currentPalette][i].peRed;
2465                 table[i][1] = device->palettes[device->currentPalette][i].peGreen;
2466                 table[i][2] = device->palettes[device->currentPalette][i].peBlue;
2467                 table[i][3] = device->palettes[device->currentPalette][i].peFlags;
2468             }
2469         }
2470     }
2471     else
2472     {
2473         TRACE("Using surface palette %p\n", pal);
2474         /* Get the surface's palette */
2475         for (i = 0; i < 256; ++i)
2476         {
2477             table[i][0] = pal->palents[i].peRed;
2478             table[i][1] = pal->palents[i].peGreen;
2479             table[i][2] = pal->palents[i].peBlue;
2480
2481             /* When index_in_alpha is set the palette index is stored in the
2482              * alpha component. In case of a readback we can then read
2483              * GL_ALPHA. Color keying is handled in BltOverride using a
2484              * GL_ALPHA_TEST using GL_NOT_EQUAL. In case of index_in_alpha the
2485              * color key itself is passed to glAlphaFunc in other cases the
2486              * alpha component of pixels that should be masked away is set to 0. */
2487             if (index_in_alpha)
2488             {
2489                 table[i][3] = i;
2490             }
2491             else if (colorkey && (i >= This->SrcBltCKey.dwColorSpaceLowValue)
2492                     && (i <= This->SrcBltCKey.dwColorSpaceHighValue))
2493             {
2494                 table[i][3] = 0x00;
2495             }
2496             else if (pal->flags & WINEDDPCAPS_ALPHA)
2497             {
2498                 table[i][3] = pal->palents[i].peFlags;
2499             }
2500             else
2501             {
2502                 table[i][3] = 0xFF;
2503             }
2504         }
2505     }
2506 }
2507
2508 static HRESULT d3dfmt_convert_surface(const BYTE *src, BYTE *dst, UINT pitch, UINT width,
2509         UINT height, UINT outpitch, CONVERT_TYPES convert, IWineD3DSurfaceImpl *This)
2510 {
2511     const BYTE *source;
2512     BYTE *dest;
2513     TRACE("(%p)->(%p),(%d,%d,%d,%d,%p)\n", src, dst, pitch, height, outpitch, convert,This);
2514
2515     switch (convert) {
2516         case NO_CONVERSION:
2517         {
2518             memcpy(dst, src, pitch * height);
2519             break;
2520         }
2521         case CONVERT_PALETTED:
2522         case CONVERT_PALETTED_CK:
2523         {
2524             BYTE table[256][4];
2525             unsigned int x, y;
2526
2527             d3dfmt_p8_init_palette(This, table, (convert == CONVERT_PALETTED_CK));
2528
2529             for (y = 0; y < height; y++)
2530             {
2531                 source = src + pitch * y;
2532                 dest = dst + outpitch * y;
2533                 /* This is an 1 bpp format, using the width here is fine */
2534                 for (x = 0; x < width; x++) {
2535                     BYTE color = *source++;
2536                     *dest++ = table[color][0];
2537                     *dest++ = table[color][1];
2538                     *dest++ = table[color][2];
2539                     *dest++ = table[color][3];
2540                 }
2541             }
2542         }
2543         break;
2544
2545         case CONVERT_CK_565:
2546         {
2547             /* Converting the 565 format in 5551 packed to emulate color-keying.
2548
2549               Note : in all these conversion, it would be best to average the averaging
2550                       pixels to get the color of the pixel that will be color-keyed to
2551                       prevent 'color bleeding'. This will be done later on if ever it is
2552                       too visible.
2553
2554               Note2: Nvidia documents say that their driver does not support alpha + color keying
2555                      on the same surface and disables color keying in such a case
2556             */
2557             unsigned int x, y;
2558             const WORD *Source;
2559             WORD *Dest;
2560
2561             TRACE("Color keyed 565\n");
2562
2563             for (y = 0; y < height; y++) {
2564                 Source = (const WORD *)(src + y * pitch);
2565                 Dest = (WORD *) (dst + y * outpitch);
2566                 for (x = 0; x < width; x++ ) {
2567                     WORD color = *Source++;
2568                     *Dest = ((color & 0xFFC0) | ((color & 0x1F) << 1));
2569                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2570                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2571                         *Dest |= 0x0001;
2572                     }
2573                     Dest++;
2574                 }
2575             }
2576         }
2577         break;
2578
2579         case CONVERT_CK_5551:
2580         {
2581             /* Converting X1R5G5B5 format to R5G5B5A1 to emulate color-keying. */
2582             unsigned int x, y;
2583             const WORD *Source;
2584             WORD *Dest;
2585             TRACE("Color keyed 5551\n");
2586             for (y = 0; y < height; y++) {
2587                 Source = (const WORD *)(src + y * pitch);
2588                 Dest = (WORD *) (dst + y * outpitch);
2589                 for (x = 0; x < width; x++ ) {
2590                     WORD color = *Source++;
2591                     *Dest = color;
2592                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2593                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2594                         *Dest |= (1 << 15);
2595                     }
2596                     else {
2597                         *Dest &= ~(1 << 15);
2598                     }
2599                     Dest++;
2600                 }
2601             }
2602         }
2603         break;
2604
2605         case CONVERT_CK_RGB24:
2606         {
2607             /* Converting R8G8B8 format to R8G8B8A8 with color-keying. */
2608             unsigned int x, y;
2609             for (y = 0; y < height; y++)
2610             {
2611                 source = src + pitch * y;
2612                 dest = dst + outpitch * y;
2613                 for (x = 0; x < width; x++) {
2614                     DWORD color = ((DWORD)source[0] << 16) + ((DWORD)source[1] << 8) + (DWORD)source[2] ;
2615                     DWORD dstcolor = color << 8;
2616                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2617                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2618                         dstcolor |= 0xff;
2619                     }
2620                     *(DWORD*)dest = dstcolor;
2621                     source += 3;
2622                     dest += 4;
2623                 }
2624             }
2625         }
2626         break;
2627
2628         case CONVERT_RGB32_888:
2629         {
2630             /* Converting X8R8G8B8 format to R8G8B8A8 with color-keying. */
2631             unsigned int x, y;
2632             for (y = 0; y < height; y++)
2633             {
2634                 source = src + pitch * y;
2635                 dest = dst + outpitch * y;
2636                 for (x = 0; x < width; x++) {
2637                     DWORD color = 0xffffff & *(const DWORD*)source;
2638                     DWORD dstcolor = color << 8;
2639                     if ((color < This->SrcBltCKey.dwColorSpaceLowValue) ||
2640                         (color > This->SrcBltCKey.dwColorSpaceHighValue)) {
2641                         dstcolor |= 0xff;
2642                     }
2643                     *(DWORD*)dest = dstcolor;
2644                     source += 4;
2645                     dest += 4;
2646                 }
2647             }
2648         }
2649         break;
2650
2651         default:
2652             ERR("Unsupported conversion type %#x.\n", convert);
2653     }
2654     return WINED3D_OK;
2655 }
2656
2657 BOOL palette9_changed(IWineD3DSurfaceImpl *This)
2658 {
2659     IWineD3DDeviceImpl *device = This->resource.device;
2660
2661     if (This->palette || (This->resource.format->id != WINED3DFMT_P8_UINT
2662             && This->resource.format->id != WINED3DFMT_P8_UINT_A8_UNORM))
2663     {
2664         /* If a ddraw-style palette is attached assume no d3d9 palette change.
2665          * Also the palette isn't interesting if the surface format isn't P8 or A8P8
2666          */
2667         return FALSE;
2668     }
2669
2670     if (This->palette9)
2671     {
2672         if (!memcmp(This->palette9, device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256))
2673         {
2674             return FALSE;
2675         }
2676     } else {
2677         This->palette9 = HeapAlloc(GetProcessHeap(), 0, sizeof(PALETTEENTRY) * 256);
2678     }
2679     memcpy(This->palette9, device->palettes[device->currentPalette], sizeof(PALETTEENTRY) * 256);
2680     return TRUE;
2681 }
2682
2683 static HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, enum wined3d_format_id format)
2684 {
2685     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2686     HRESULT hr;
2687
2688     TRACE("(%p) : Calling base function first\n", This);
2689     hr = IWineD3DBaseSurfaceImpl_SetFormat(iface, format);
2690     if (SUCCEEDED(hr))
2691     {
2692         This->flags &= ~(SFLAG_ALLOCATED | SFLAG_SRGBALLOCATED);
2693         TRACE("(%p) : glFormat %d, glFormatInternal %d, glType %d\n", This, This->resource.format->glFormat,
2694                 This->resource.format->glInternal, This->resource.format->glType);
2695     }
2696     return hr;
2697 }
2698
2699 static HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem) {
2700     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
2701
2702     TRACE("iface %p, mem %p.\n", iface, Mem);
2703
2704     if (This->flags & (SFLAG_LOCKED | SFLAG_DCINUSE))
2705     {
2706         WARN("Surface is locked or the HDC is in use\n");
2707         return WINED3DERR_INVALIDCALL;
2708     }
2709
2710     if(Mem && Mem != This->resource.allocatedMemory) {
2711         void *release = NULL;
2712
2713         /* Do I have to copy the old surface content? */
2714         if (This->flags & SFLAG_DIBSECTION)
2715         {
2716             SelectObject(This->hDC, This->dib.holdbitmap);
2717             DeleteDC(This->hDC);
2718             /* Release the DIB section */
2719             DeleteObject(This->dib.DIBsection);
2720             This->dib.bitmap_data = NULL;
2721             This->resource.allocatedMemory = NULL;
2722             This->hDC = NULL;
2723             This->flags &= ~SFLAG_DIBSECTION;
2724         }
2725         else if (!(This->flags & SFLAG_USERPTR))
2726         {
2727             release = This->resource.heapMemory;
2728             This->resource.heapMemory = NULL;
2729         }
2730         This->resource.allocatedMemory = Mem;
2731         This->flags |= SFLAG_USERPTR;
2732
2733         /* Now the surface memory is most up do date. Invalidate drawable and texture */
2734         surface_modify_location(This, SFLAG_INSYSMEM, TRUE);
2735
2736         /* For client textures opengl has to be notified */
2737         if (This->flags & SFLAG_CLIENT)
2738             surface_release_client_storage(This);
2739
2740         /* Now free the old memory if any */
2741         HeapFree(GetProcessHeap(), 0, release);
2742     }
2743     else if (This->flags & SFLAG_USERPTR)
2744     {
2745         /* Map and GetDC will re-create the dib section and allocated memory. */
2746         This->resource.allocatedMemory = NULL;
2747         /* HeapMemory should be NULL already */
2748         if (This->resource.heapMemory)
2749             ERR("User pointer surface has heap memory allocated.\n");
2750         This->flags &= ~(SFLAG_USERPTR | SFLAG_INSYSMEM);
2751
2752         if (This->flags & SFLAG_CLIENT)
2753             surface_release_client_storage(This);
2754
2755         surface_prepare_system_memory(This);
2756         surface_modify_location(This, SFLAG_INSYSMEM, TRUE);
2757     }
2758     return WINED3D_OK;
2759 }
2760
2761 void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) {
2762
2763     /* Flip the surface contents */
2764     /* Flip the DC */
2765     {
2766         HDC tmp;
2767         tmp = front->hDC;
2768         front->hDC = back->hDC;
2769         back->hDC = tmp;
2770     }
2771
2772     /* Flip the DIBsection */
2773     {
2774         HBITMAP tmp;
2775         BOOL hasDib = front->flags & SFLAG_DIBSECTION;
2776         tmp = front->dib.DIBsection;
2777         front->dib.DIBsection = back->dib.DIBsection;
2778         back->dib.DIBsection = tmp;
2779
2780         if (back->flags & SFLAG_DIBSECTION) front->flags |= SFLAG_DIBSECTION;
2781         else front->flags &= ~SFLAG_DIBSECTION;
2782         if (hasDib) back->flags |= SFLAG_DIBSECTION;
2783         else back->flags &= ~SFLAG_DIBSECTION;
2784     }
2785
2786     /* Flip the surface data */
2787     {
2788         void* tmp;
2789
2790         tmp = front->dib.bitmap_data;
2791         front->dib.bitmap_data = back->dib.bitmap_data;
2792         back->dib.bitmap_data = tmp;
2793
2794         tmp = front->resource.allocatedMemory;
2795         front->resource.allocatedMemory = back->resource.allocatedMemory;
2796         back->resource.allocatedMemory = tmp;
2797
2798         tmp = front->resource.heapMemory;
2799         front->resource.heapMemory = back->resource.heapMemory;
2800         back->resource.heapMemory = tmp;
2801     }
2802
2803     /* Flip the PBO */
2804     {
2805         GLuint tmp_pbo = front->pbo;
2806         front->pbo = back->pbo;
2807         back->pbo = tmp_pbo;
2808     }
2809
2810     /* client_memory should not be different, but just in case */
2811     {
2812         BOOL tmp;
2813         tmp = front->dib.client_memory;
2814         front->dib.client_memory = back->dib.client_memory;
2815         back->dib.client_memory = tmp;
2816     }
2817
2818     /* Flip the opengl texture */
2819     {
2820         GLuint tmp;
2821
2822         tmp = back->texture_name;
2823         back->texture_name = front->texture_name;
2824         front->texture_name = tmp;
2825
2826         tmp = back->texture_name_srgb;
2827         back->texture_name_srgb = front->texture_name_srgb;
2828         front->texture_name_srgb = tmp;
2829
2830         resource_unload(&back->resource);
2831         resource_unload(&front->resource);
2832     }
2833
2834     {
2835         DWORD tmp_flags = back->flags;
2836         back->flags = front->flags;
2837         front->flags = tmp_flags;
2838     }
2839 }
2840
2841 static HRESULT WINAPI IWineD3DSurfaceImpl_Flip(IWineD3DSurface *iface, IWineD3DSurface *override, DWORD flags)
2842 {
2843     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
2844     IWineD3DSwapChainImpl *swapchain = NULL;
2845
2846     TRACE("iface %p, override %p, flags %#x.\n", iface, override, flags);
2847
2848     /* Flipping is only supported on RenderTargets and overlays*/
2849     if( !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_OVERLAY)) ) {
2850         WARN("Tried to flip a non-render target, non-overlay surface\n");
2851         return WINEDDERR_NOTFLIPPABLE;
2852     }
2853
2854     if(This->resource.usage & WINED3DUSAGE_OVERLAY) {
2855         flip_surface(This, (IWineD3DSurfaceImpl *) override);
2856
2857         /* Update the overlay if it is visible */
2858         if (This->overlay_dest)
2859             return This->surface_ops->surface_draw_overlay(This);
2860         else
2861             return WINED3D_OK;
2862     }
2863
2864     if(override) {
2865         /* DDraw sets this for the X11 surfaces, so don't confuse the user
2866          * FIXME("(%p) Target override is not supported by now\n", This);
2867          * Additionally, it isn't really possible to support triple-buffering
2868          * properly on opengl at all
2869          */
2870     }
2871
2872     if (This->container.type != WINED3D_CONTAINER_SWAPCHAIN)
2873     {
2874         ERR("Flipped surface is not on a swapchain\n");
2875         return WINEDDERR_NOTFLIPPABLE;
2876     }
2877     swapchain = This->container.u.swapchain;
2878
2879     /* Just overwrite the swapchain presentation interval. This is ok because only ddraw apps can call Flip,
2880      * and only d3d8 and d3d9 apps specify the presentation interval
2881      */
2882     if (!(flags & (WINEDDFLIP_NOVSYNC | WINEDDFLIP_INTERVAL2 | WINEDDFLIP_INTERVAL3 | WINEDDFLIP_INTERVAL4)))
2883         /* Most common case first to avoid wasting time on all the other cases */
2884         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_ONE;
2885     else if (flags & WINEDDFLIP_NOVSYNC)
2886         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
2887     else if (flags & WINEDDFLIP_INTERVAL2)
2888         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_TWO;
2889     else if (flags & WINEDDFLIP_INTERVAL3)
2890         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_THREE;
2891     else
2892         swapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_FOUR;
2893
2894     /* Flipping a OpenGL surface -> Use WineD3DDevice::Present */
2895     return IWineD3DSwapChain_Present((IWineD3DSwapChain *)swapchain,
2896             NULL, NULL, swapchain->win_handle, NULL, 0);
2897 }
2898
2899 /* Does a direct frame buffer -> texture copy. Stretching is done
2900  * with single pixel copy calls
2901  */
2902 static void fb_copy_to_texture_direct(IWineD3DSurfaceImpl *dst_surface, IWineD3DSurfaceImpl *src_surface,
2903         const RECT *src_rect, const RECT *dst_rect_in, WINED3DTEXTUREFILTERTYPE Filter)
2904 {
2905     IWineD3DDeviceImpl *device = dst_surface->resource.device;
2906     float xrel, yrel;
2907     UINT row;
2908     struct wined3d_context *context;
2909     BOOL upsidedown = FALSE;
2910     RECT dst_rect = *dst_rect_in;
2911
2912     /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
2913      * glCopyTexSubImage is a bit picky about the parameters we pass to it
2914      */
2915     if(dst_rect.top > dst_rect.bottom) {
2916         UINT tmp = dst_rect.bottom;
2917         dst_rect.bottom = dst_rect.top;
2918         dst_rect.top = tmp;
2919         upsidedown = TRUE;
2920     }
2921
2922     context = context_acquire(device, src_surface);
2923     context_apply_blit_state(context, device);
2924     surface_internal_preload(dst_surface, SRGB_RGB);
2925     ENTER_GL();
2926
2927     /* Bind the target texture */
2928     glBindTexture(dst_surface->texture_target, dst_surface->texture_name);
2929     checkGLcall("glBindTexture");
2930     if (surface_is_offscreen(src_surface))
2931     {
2932         TRACE("Reading from an offscreen target\n");
2933         upsidedown = !upsidedown;
2934         glReadBuffer(device->offscreenBuffer);
2935     }
2936     else
2937     {
2938         glReadBuffer(surface_get_gl_buffer(src_surface));
2939     }
2940     checkGLcall("glReadBuffer");
2941
2942     xrel = (float) (src_rect->right - src_rect->left) / (float) (dst_rect.right - dst_rect.left);
2943     yrel = (float) (src_rect->bottom - src_rect->top) / (float) (dst_rect.bottom - dst_rect.top);
2944
2945     if ((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
2946     {
2947         FIXME("Doing a pixel by pixel copy from the framebuffer to a texture, expect major performance issues\n");
2948
2949         if(Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT) {
2950             ERR("Texture filtering not supported in direct blit\n");
2951         }
2952     }
2953     else if ((Filter != WINED3DTEXF_NONE && Filter != WINED3DTEXF_POINT)
2954             && ((yrel - 1.0f < -eps) || (yrel - 1.0f > eps)))
2955     {
2956         ERR("Texture filtering not supported in direct blit\n");
2957     }
2958
2959     if (upsidedown
2960             && !((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
2961             && !((yrel - 1.0f < -eps) || (yrel - 1.0f > eps)))
2962     {
2963         /* Upside down copy without stretching is nice, one glCopyTexSubImage call will do */
2964
2965         glCopyTexSubImage2D(dst_surface->texture_target, dst_surface->texture_level,
2966                 dst_rect.left /*xoffset */, dst_rect.top /* y offset */,
2967                 src_rect->left, src_surface->resource.height - src_rect->bottom,
2968                 dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top);
2969     }
2970     else
2971     {
2972         UINT yoffset = src_surface->resource.height - src_rect->top + dst_rect.top - 1;
2973         /* I have to process this row by row to swap the image,
2974          * otherwise it would be upside down, so stretching in y direction
2975          * doesn't cost extra time
2976          *
2977          * However, stretching in x direction can be avoided if not necessary
2978          */
2979         for(row = dst_rect.top; row < dst_rect.bottom; row++) {
2980             if ((xrel - 1.0f < -eps) || (xrel - 1.0f > eps))
2981             {
2982                 /* Well, that stuff works, but it's very slow.
2983                  * find a better way instead
2984                  */
2985                 UINT col;
2986
2987                 for (col = dst_rect.left; col < dst_rect.right; ++col)
2988                 {
2989                     glCopyTexSubImage2D(dst_surface->texture_target, dst_surface->texture_level,
2990                             dst_rect.left + col /* x offset */, row /* y offset */,
2991                             src_rect->left + col * xrel, yoffset - (int) (row * yrel), 1, 1);
2992                 }
2993             }
2994             else
2995             {
2996                 glCopyTexSubImage2D(dst_surface->texture_target, dst_surface->texture_level,
2997                         dst_rect.left /* x offset */, row /* y offset */,
2998                         src_rect->left, yoffset - (int) (row * yrel), dst_rect.right - dst_rect.left, 1);
2999             }
3000         }
3001     }
3002     checkGLcall("glCopyTexSubImage2D");
3003
3004     LEAVE_GL();
3005     context_release(context);
3006
3007     /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3008      * path is never entered
3009      */
3010     surface_modify_location(dst_surface, SFLAG_INTEXTURE, TRUE);
3011 }
3012
3013 /* Uses the hardware to stretch and flip the image */
3014 static void fb_copy_to_texture_hwstretch(IWineD3DSurfaceImpl *dst_surface, IWineD3DSurfaceImpl *src_surface,
3015         const RECT *src_rect, const RECT *dst_rect_in, WINED3DTEXTUREFILTERTYPE Filter)
3016 {
3017     IWineD3DDeviceImpl *device = dst_surface->resource.device;
3018     GLuint src, backup = 0;
3019     IWineD3DSwapChainImpl *src_swapchain = NULL;
3020     float left, right, top, bottom; /* Texture coordinates */
3021     UINT fbwidth = src_surface->resource.width;
3022     UINT fbheight = src_surface->resource.height;
3023     struct wined3d_context *context;
3024     GLenum drawBuffer = GL_BACK;
3025     GLenum texture_target;
3026     BOOL noBackBufferBackup;
3027     BOOL src_offscreen;
3028     BOOL upsidedown = FALSE;
3029     RECT dst_rect = *dst_rect_in;
3030
3031     TRACE("Using hwstretch blit\n");
3032     /* Activate the Proper context for reading from the source surface, set it up for blitting */
3033     context = context_acquire(device, src_surface);
3034     context_apply_blit_state(context, device);
3035     surface_internal_preload(dst_surface, SRGB_RGB);
3036
3037     src_offscreen = surface_is_offscreen(src_surface);
3038     noBackBufferBackup = src_offscreen && wined3d_settings.offscreen_rendering_mode == ORM_FBO;
3039     if (!noBackBufferBackup && !src_surface->texture_name)
3040     {
3041         /* Get it a description */
3042         surface_internal_preload(src_surface, SRGB_RGB);
3043     }
3044     ENTER_GL();
3045
3046     /* Try to use an aux buffer for drawing the rectangle. This way it doesn't need restoring.
3047      * This way we don't have to wait for the 2nd readback to finish to leave this function.
3048      */
3049     if (context->aux_buffers >= 2)
3050     {
3051         /* Got more than one aux buffer? Use the 2nd aux buffer */
3052         drawBuffer = GL_AUX1;
3053     }
3054     else if ((!src_offscreen || device->offscreenBuffer == GL_BACK) && context->aux_buffers >= 1)
3055     {
3056         /* Only one aux buffer, but it isn't used (Onscreen rendering, or non-aux orm)? Use it! */
3057         drawBuffer = GL_AUX0;
3058     }
3059
3060     if(noBackBufferBackup) {
3061         glGenTextures(1, &backup);
3062         checkGLcall("glGenTextures");
3063         glBindTexture(GL_TEXTURE_2D, backup);
3064         checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3065         texture_target = GL_TEXTURE_2D;
3066     } else {
3067         /* Backup the back buffer and copy the source buffer into a texture to draw an upside down stretched quad. If
3068          * we are reading from the back buffer, the backup can be used as source texture
3069          */
3070         texture_target = src_surface->texture_target;
3071         glBindTexture(texture_target, src_surface->texture_name);
3072         checkGLcall("glBindTexture(texture_target, src_surface->texture_name)");
3073         glEnable(texture_target);
3074         checkGLcall("glEnable(texture_target)");
3075
3076         /* For now invalidate the texture copy of the back buffer. Drawable and sysmem copy are untouched */
3077         src_surface->flags &= ~SFLAG_INTEXTURE;
3078     }
3079
3080     /* Make sure that the top pixel is always above the bottom pixel, and keep a separate upside down flag
3081      * glCopyTexSubImage is a bit picky about the parameters we pass to it
3082      */
3083     if(dst_rect.top > dst_rect.bottom) {
3084         UINT tmp = dst_rect.bottom;
3085         dst_rect.bottom = dst_rect.top;
3086         dst_rect.top = tmp;
3087         upsidedown = TRUE;
3088     }
3089
3090     if (src_offscreen)
3091     {
3092         TRACE("Reading from an offscreen target\n");
3093         upsidedown = !upsidedown;
3094         glReadBuffer(device->offscreenBuffer);
3095     }
3096     else
3097     {
3098         glReadBuffer(surface_get_gl_buffer(src_surface));
3099     }
3100
3101     /* TODO: Only back up the part that will be overwritten */
3102     glCopyTexSubImage2D(texture_target, 0,
3103                         0, 0 /* read offsets */,
3104                         0, 0,
3105                         fbwidth,
3106                         fbheight);
3107
3108     checkGLcall("glCopyTexSubImage2D");
3109
3110     /* No issue with overriding these - the sampler is dirty due to blit usage */
3111     glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER,
3112             wined3d_gl_mag_filter(magLookup, Filter));
3113     checkGLcall("glTexParameteri");
3114     glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER,
3115             wined3d_gl_min_mip_filter(minMipLookup, Filter, WINED3DTEXF_NONE));
3116     checkGLcall("glTexParameteri");
3117
3118     if (src_surface->container.type == WINED3D_CONTAINER_SWAPCHAIN)
3119         src_swapchain = src_surface->container.u.swapchain;
3120     if (!src_swapchain || src_surface == src_swapchain->back_buffers[0])
3121     {
3122         src = backup ? backup : src_surface->texture_name;
3123     }
3124     else
3125     {
3126         glReadBuffer(GL_FRONT);
3127         checkGLcall("glReadBuffer(GL_FRONT)");
3128
3129         glGenTextures(1, &src);
3130         checkGLcall("glGenTextures(1, &src)");
3131         glBindTexture(GL_TEXTURE_2D, src);
3132         checkGLcall("glBindTexture(GL_TEXTURE_2D, src)");
3133
3134         /* TODO: Only copy the part that will be read. Use src_rect->left, src_rect->bottom as origin, but with the width watch
3135          * out for power of 2 sizes
3136          */
3137         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, src_surface->pow2Width,
3138                 src_surface->pow2Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
3139         checkGLcall("glTexImage2D");
3140         glCopyTexSubImage2D(GL_TEXTURE_2D, 0,
3141                             0, 0 /* read offsets */,
3142                             0, 0,
3143                             fbwidth,
3144                             fbheight);
3145
3146         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
3147         checkGLcall("glTexParameteri");
3148         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
3149         checkGLcall("glTexParameteri");
3150
3151         glReadBuffer(GL_BACK);
3152         checkGLcall("glReadBuffer(GL_BACK)");
3153
3154         if(texture_target != GL_TEXTURE_2D) {
3155             glDisable(texture_target);
3156             glEnable(GL_TEXTURE_2D);
3157             texture_target = GL_TEXTURE_2D;
3158         }
3159     }
3160     checkGLcall("glEnd and previous");
3161
3162     left = src_rect->left;
3163     right = src_rect->right;
3164
3165     if (!upsidedown)
3166     {
3167         top = src_surface->resource.height - src_rect->top;
3168         bottom = src_surface->resource.height - src_rect->bottom;
3169     }
3170     else
3171     {
3172         top = src_surface->resource.height - src_rect->bottom;
3173         bottom = src_surface->resource.height - src_rect->top;
3174     }
3175
3176     if (src_surface->flags & SFLAG_NORMCOORD)
3177     {
3178         left /= src_surface->pow2Width;
3179         right /= src_surface->pow2Width;
3180         top /= src_surface->pow2Height;
3181         bottom /= src_surface->pow2Height;
3182     }
3183
3184     /* draw the source texture stretched and upside down. The correct surface is bound already */
3185     glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP);
3186     glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP);
3187
3188     context_set_draw_buffer(context, drawBuffer);
3189     glReadBuffer(drawBuffer);
3190
3191     glBegin(GL_QUADS);
3192         /* bottom left */
3193         glTexCoord2f(left, bottom);
3194         glVertex2i(0, 0);
3195
3196         /* top left */
3197         glTexCoord2f(left, top);
3198         glVertex2i(0, dst_rect.bottom - dst_rect.top);
3199
3200         /* top right */
3201         glTexCoord2f(right, top);
3202         glVertex2i(dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top);
3203
3204         /* bottom right */
3205         glTexCoord2f(right, bottom);
3206         glVertex2i(dst_rect.right - dst_rect.left, 0);
3207     glEnd();
3208     checkGLcall("glEnd and previous");
3209
3210     if (texture_target != dst_surface->texture_target)
3211     {
3212         glDisable(texture_target);
3213         glEnable(dst_surface->texture_target);
3214         texture_target = dst_surface->texture_target;
3215     }
3216
3217     /* Now read the stretched and upside down image into the destination texture */
3218     glBindTexture(texture_target, dst_surface->texture_name);
3219     checkGLcall("glBindTexture");
3220     glCopyTexSubImage2D(texture_target,
3221                         0,
3222                         dst_rect.left, dst_rect.top, /* xoffset, yoffset */
3223                         0, 0, /* We blitted the image to the origin */
3224                         dst_rect.right - dst_rect.left, dst_rect.bottom - dst_rect.top);
3225     checkGLcall("glCopyTexSubImage2D");
3226
3227     if(drawBuffer == GL_BACK) {
3228         /* Write the back buffer backup back */
3229         if(backup) {
3230             if(texture_target != GL_TEXTURE_2D) {
3231                 glDisable(texture_target);
3232                 glEnable(GL_TEXTURE_2D);
3233                 texture_target = GL_TEXTURE_2D;
3234             }
3235             glBindTexture(GL_TEXTURE_2D, backup);
3236             checkGLcall("glBindTexture(GL_TEXTURE_2D, backup)");
3237         }
3238         else
3239         {
3240             if (texture_target != src_surface->texture_target)
3241             {
3242                 glDisable(texture_target);
3243                 glEnable(src_surface->texture_target);
3244                 texture_target = src_surface->texture_target;
3245             }
3246             glBindTexture(src_surface->texture_target, src_surface->texture_name);
3247             checkGLcall("glBindTexture(src_surface->texture_target, src_surface->texture_name)");
3248         }
3249
3250         glBegin(GL_QUADS);
3251             /* top left */
3252             glTexCoord2f(0.0f, 0.0f);
3253             glVertex2i(0, fbheight);
3254
3255             /* bottom left */
3256             glTexCoord2f(0.0f, (float)fbheight / (float)src_surface->pow2Height);
3257             glVertex2i(0, 0);
3258
3259             /* bottom right */
3260             glTexCoord2f((float)fbwidth / (float)src_surface->pow2Width,
3261                     (float)fbheight / (float)src_surface->pow2Height);
3262             glVertex2i(fbwidth, 0);
3263
3264             /* top right */
3265             glTexCoord2f((float)fbwidth / (float)src_surface->pow2Width, 0.0f);
3266             glVertex2i(fbwidth, fbheight);
3267         glEnd();
3268     }
3269     glDisable(texture_target);
3270     checkGLcall("glDisable(texture_target)");
3271
3272     /* Cleanup */
3273     if (src != src_surface->texture_name && src != backup)
3274     {
3275         glDeleteTextures(1, &src);
3276         checkGLcall("glDeleteTextures(1, &src)");
3277     }
3278     if(backup) {
3279         glDeleteTextures(1, &backup);
3280         checkGLcall("glDeleteTextures(1, &backup)");
3281     }
3282
3283     LEAVE_GL();
3284
3285     if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
3286
3287     context_release(context);
3288
3289     /* The texture is now most up to date - If the surface is a render target and has a drawable, this
3290      * path is never entered
3291      */
3292     surface_modify_location(dst_surface, SFLAG_INTEXTURE, TRUE);
3293 }
3294
3295 /* Until the blit_shader is ready, define some prototypes here. */
3296 static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
3297         const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
3298         const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format);
3299
3300 /* Front buffer coordinates are always full screen coordinates, but our GL
3301  * drawable is limited to the window's client area. The sysmem and texture
3302  * copies do have the full screen size. Note that GL has a bottom-left
3303  * origin, while D3D has a top-left origin. */
3304 void surface_translate_drawable_coords(IWineD3DSurfaceImpl *surface, HWND window, RECT *rect)
3305 {
3306     UINT drawable_height;
3307
3308     if (surface->container.type == WINED3D_CONTAINER_SWAPCHAIN
3309             && surface == surface->container.u.swapchain->front_buffer)
3310     {
3311         POINT offset = {0, 0};
3312         RECT windowsize;
3313
3314         ScreenToClient(window, &offset);
3315         OffsetRect(rect, offset.x, offset.y);
3316
3317         GetClientRect(window, &windowsize);
3318         drawable_height = windowsize.bottom - windowsize.top;
3319     }
3320     else
3321     {
3322         drawable_height = surface->resource.height;
3323     }
3324
3325     rect->top = drawable_height - rect->top;
3326     rect->bottom = drawable_height - rect->bottom;
3327 }
3328
3329 static BOOL surface_is_full_rect(IWineD3DSurfaceImpl *surface, const RECT *r)
3330 {
3331     if ((r->left && r->right) || abs(r->right - r->left) != surface->resource.width)
3332         return FALSE;
3333     if ((r->top && r->bottom) || abs(r->bottom - r->top) != surface->resource.height)
3334         return FALSE;
3335     return TRUE;
3336 }
3337
3338 /* blit between surface locations. onscreen on different swapchains is not supported.
3339  * depth / stencil is not supported. */
3340 static void surface_blt_fbo(IWineD3DDeviceImpl *device, const WINED3DTEXTUREFILTERTYPE filter,
3341         IWineD3DSurfaceImpl *src_surface, DWORD src_location, const RECT *src_rect_in,
3342         IWineD3DSurfaceImpl *dst_surface, DWORD dst_location, const RECT *dst_rect_in)
3343 {
3344     const struct wined3d_gl_info *gl_info;
3345     struct wined3d_context *context;
3346     RECT src_rect, dst_rect;
3347     GLenum gl_filter;
3348
3349     TRACE("device %p, filter %s,\n", device, debug_d3dtexturefiltertype(filter));
3350     TRACE("src_surface %p, src_location %s, src_rect %s,\n",
3351             src_surface, debug_surflocation(src_location), wine_dbgstr_rect(src_rect_in));
3352     TRACE("dst_surface %p, dst_location %s, dst_rect %s.\n",
3353             dst_surface, debug_surflocation(dst_location), wine_dbgstr_rect(dst_rect_in));
3354
3355     src_rect = *src_rect_in;
3356     dst_rect = *dst_rect_in;
3357
3358     switch (filter)
3359     {
3360         case WINED3DTEXF_LINEAR:
3361             gl_filter = GL_LINEAR;
3362             break;
3363
3364         default:
3365             FIXME("Unsupported filter mode %s (%#x).\n", debug_d3dtexturefiltertype(filter), filter);
3366         case WINED3DTEXF_NONE:
3367         case WINED3DTEXF_POINT:
3368             gl_filter = GL_NEAREST;
3369             break;
3370     }
3371
3372     if (src_location == SFLAG_INDRAWABLE && surface_is_offscreen(src_surface))
3373         src_location = SFLAG_INTEXTURE;
3374     if (dst_location == SFLAG_INDRAWABLE && surface_is_offscreen(dst_surface))
3375         dst_location = SFLAG_INTEXTURE;
3376
3377     /* Make sure the locations are up-to-date. Loading the destination
3378      * surface isn't required if the entire surface is overwritten. (And is
3379      * in fact harmful if we're being called by surface_load_location() with
3380      * the purpose of loading the destination surface.) */
3381     surface_load_location(src_surface, src_location, NULL);
3382     if (!surface_is_full_rect(dst_surface, &dst_rect))
3383         surface_load_location(dst_surface, dst_location, NULL);
3384
3385     if (src_location == SFLAG_INDRAWABLE) context = context_acquire(device, src_surface);
3386     else if (dst_location == SFLAG_INDRAWABLE) context = context_acquire(device, dst_surface);
3387     else context = context_acquire(device, NULL);
3388
3389     if (!context->valid)
3390     {
3391         context_release(context);
3392         WARN("Invalid context, skipping blit.\n");
3393         return;
3394     }
3395
3396     gl_info = context->gl_info;
3397
3398     if (src_location == SFLAG_INDRAWABLE)
3399     {
3400         GLenum buffer = surface_get_gl_buffer(src_surface);
3401
3402         TRACE("Source surface %p is onscreen.\n", src_surface);
3403
3404         surface_translate_drawable_coords(src_surface, context->win_handle, &src_rect);
3405
3406         ENTER_GL();
3407         context_bind_fbo(context, GL_READ_FRAMEBUFFER, NULL);
3408         glReadBuffer(buffer);
3409         checkGLcall("glReadBuffer()");
3410     }
3411     else
3412     {
3413         TRACE("Source surface %p is offscreen.\n", src_surface);
3414         ENTER_GL();
3415         context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, src_surface, NULL, src_location);
3416         glReadBuffer(GL_COLOR_ATTACHMENT0);
3417         checkGLcall("glReadBuffer()");
3418     }
3419     LEAVE_GL();
3420
3421     if (dst_location == SFLAG_INDRAWABLE)
3422     {
3423         GLenum buffer = surface_get_gl_buffer(dst_surface);
3424
3425         TRACE("Destination surface %p is onscreen.\n", dst_surface);
3426
3427         surface_translate_drawable_coords(dst_surface, context->win_handle, &dst_rect);
3428
3429         ENTER_GL();
3430         context_bind_fbo(context, GL_DRAW_FRAMEBUFFER, NULL);
3431         context_set_draw_buffer(context, buffer);
3432     }
3433     else
3434     {
3435         TRACE("Destination surface %p is offscreen.\n", dst_surface);
3436
3437         ENTER_GL();
3438         context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, dst_surface, NULL, dst_location);
3439         context_set_draw_buffer(context, GL_COLOR_ATTACHMENT0);
3440     }
3441
3442     glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
3443     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_COLORWRITEENABLE));
3444     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_COLORWRITEENABLE1));
3445     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_COLORWRITEENABLE2));
3446     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_COLORWRITEENABLE3));
3447
3448     glDisable(GL_SCISSOR_TEST);
3449     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
3450
3451     gl_info->fbo_ops.glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom,
3452             dst_rect.left, dst_rect.top, dst_rect.right, dst_rect.bottom, GL_COLOR_BUFFER_BIT, gl_filter);
3453     checkGLcall("glBlitFramebuffer()");
3454
3455     LEAVE_GL();
3456
3457     if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
3458
3459     context_release(context);
3460 }
3461
3462 static void wined3d_surface_depth_blt_fbo(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *src_surface,
3463         const RECT *src_rect, IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect)
3464 {
3465     const struct wined3d_gl_info *gl_info;
3466     struct wined3d_context *context;
3467     DWORD src_mask, dst_mask;
3468     GLbitfield gl_mask;
3469
3470     TRACE("device %p, src_surface %p, src_rect %s, dst_surface %p, dst_rect %s.\n",
3471             device, src_surface, wine_dbgstr_rect(src_rect),
3472             dst_surface, wine_dbgstr_rect(dst_rect));
3473
3474     src_mask = src_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
3475     dst_mask = dst_surface->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
3476
3477     if (src_mask != dst_mask)
3478     {
3479         ERR("Incompatible formats %s and %s.\n",
3480                 debug_d3dformat(src_surface->resource.format->id),
3481                 debug_d3dformat(dst_surface->resource.format->id));
3482         return;
3483     }
3484
3485     if (!src_mask)
3486     {
3487         ERR("Not a depth / stencil format: %s.\n",
3488                 debug_d3dformat(src_surface->resource.format->id));
3489         return;
3490     }
3491
3492     gl_mask = 0;
3493     if (src_mask & WINED3DFMT_FLAG_DEPTH)
3494         gl_mask |= GL_DEPTH_BUFFER_BIT;
3495     if (src_mask & WINED3DFMT_FLAG_STENCIL)
3496         gl_mask |= GL_STENCIL_BUFFER_BIT;
3497
3498     /* Make sure the locations are up-to-date. Loading the destination
3499      * surface isn't required if the entire surface is overwritten. */
3500     surface_load_location(src_surface, SFLAG_INTEXTURE, NULL);
3501     if (!surface_is_full_rect(dst_surface, dst_rect))
3502         surface_load_location(dst_surface, SFLAG_INTEXTURE, NULL);
3503
3504     context = context_acquire(device, NULL);
3505     if (!context->valid)
3506     {
3507         context_release(context);
3508         WARN("Invalid context, skipping blit.\n");
3509         return;
3510     }
3511
3512     gl_info = context->gl_info;
3513
3514     ENTER_GL();
3515
3516     context_apply_fbo_state_blit(context, GL_READ_FRAMEBUFFER, NULL, src_surface, SFLAG_INTEXTURE);
3517     glReadBuffer(GL_NONE);
3518     checkGLcall("glReadBuffer()");
3519
3520     context_apply_fbo_state_blit(context, GL_DRAW_FRAMEBUFFER, NULL, dst_surface, SFLAG_INTEXTURE);
3521     context_set_draw_buffer(context, GL_NONE);
3522
3523     if (gl_mask & GL_DEPTH_BUFFER_BIT)
3524     {
3525         glDepthMask(GL_TRUE);
3526         IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_ZWRITEENABLE));
3527     }
3528     if (gl_mask & GL_STENCIL_BUFFER_BIT)
3529     {
3530         if (context->gl_info->supported[EXT_STENCIL_TWO_SIDE])
3531         {
3532             glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
3533             IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_TWOSIDEDSTENCILMODE));
3534         }
3535         glStencilMask(~0U);
3536         IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_STENCILWRITEMASK));
3537     }
3538
3539     glDisable(GL_SCISSOR_TEST);
3540     IWineD3DDeviceImpl_MarkStateDirty(device, STATE_RENDER(WINED3DRS_SCISSORTESTENABLE));
3541
3542     gl_info->fbo_ops.glBlitFramebuffer(src_rect->left, src_rect->top, src_rect->right, src_rect->bottom,
3543             dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom, gl_mask, GL_NEAREST);
3544     checkGLcall("glBlitFramebuffer()");
3545
3546     LEAVE_GL();
3547
3548     if (wined3d_settings.strict_draw_ordering)
3549         wglFlush(); /* Flush to ensure ordering across contexts. */
3550
3551     context_release(context);
3552 }
3553
3554 static void surface_blt_to_drawable(IWineD3DDeviceImpl *device,
3555         WINED3DTEXTUREFILTERTYPE filter, BOOL color_key,
3556         IWineD3DSurfaceImpl *src_surface, const RECT *src_rect_in,
3557         IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect_in)
3558 {
3559     IWineD3DSwapChainImpl *swapchain = NULL;
3560     struct wined3d_context *context;
3561     RECT src_rect, dst_rect;
3562
3563     src_rect = *src_rect_in;
3564     dst_rect = *dst_rect_in;
3565
3566     if (dst_surface->container.type == WINED3D_CONTAINER_SWAPCHAIN)
3567         swapchain = dst_surface->container.u.swapchain;
3568
3569     /* Make sure the surface is up-to-date. This should probably use
3570      * surface_load_location() and worry about the destination surface too,
3571      * unless we're overwriting it completely. */
3572     surface_internal_preload(src_surface, SRGB_RGB);
3573
3574     /* Activate the destination context, set it up for blitting */
3575     context = context_acquire(device, dst_surface);
3576     context_apply_blit_state(context, device);
3577
3578     if (!surface_is_offscreen(dst_surface))
3579         surface_translate_drawable_coords(dst_surface, context->win_handle, &dst_rect);
3580
3581     device->blitter->set_shader(device->blit_priv, context->gl_info, src_surface);
3582
3583     ENTER_GL();
3584
3585     if (color_key)
3586     {
3587         glEnable(GL_ALPHA_TEST);
3588         checkGLcall("glEnable(GL_ALPHA_TEST)");
3589
3590         /* When the primary render target uses P8, the alpha component
3591          * contains the palette index. Which means that the colorkey is one of
3592          * the palette entries. In other cases pixels that should be masked
3593          * away have alpha set to 0. */
3594         if (primary_render_target_is_p8(device))
3595             glAlphaFunc(GL_NOTEQUAL, (float)src_surface->SrcBltCKey.dwColorSpaceLowValue / 256.0f);
3596         else
3597             glAlphaFunc(GL_NOTEQUAL, 0.0f);
3598         checkGLcall("glAlphaFunc");
3599     }
3600     else
3601     {
3602         glDisable(GL_ALPHA_TEST);
3603         checkGLcall("glDisable(GL_ALPHA_TEST)");
3604     }
3605
3606     draw_textured_quad(src_surface, &src_rect, &dst_rect, filter);
3607
3608     if (color_key)
3609     {
3610         glDisable(GL_ALPHA_TEST);
3611         checkGLcall("glDisable(GL_ALPHA_TEST)");
3612     }
3613
3614     LEAVE_GL();
3615
3616     /* Leave the opengl state valid for blitting */
3617     device->blitter->unset_shader(context->gl_info);
3618
3619     if (wined3d_settings.strict_draw_ordering || (swapchain
3620             && (dst_surface == swapchain->front_buffer || swapchain->num_contexts > 1)))
3621         wglFlush(); /* Flush to ensure ordering across contexts. */
3622
3623     context_release(context);
3624 }
3625
3626 /* Do not call while under the GL lock. */
3627 HRESULT surface_color_fill(IWineD3DSurfaceImpl *s, const RECT *rect, const WINED3DCOLORVALUE *color)
3628 {
3629     IWineD3DDeviceImpl *device = s->resource.device;
3630     const struct blit_shader *blitter;
3631
3632     blitter = wined3d_select_blitter(&device->adapter->gl_info, WINED3D_BLIT_OP_COLOR_FILL,
3633             NULL, 0, 0, NULL, rect, s->resource.usage, s->resource.pool, s->resource.format);
3634     if (!blitter)
3635     {
3636         FIXME("No blitter is capable of performing the requested color fill operation.\n");
3637         return WINED3DERR_INVALIDCALL;
3638     }
3639
3640     return blitter->color_fill(device, s, rect, color);
3641 }
3642
3643 /* Not called from the VTable */
3644 /* Do not call while under the GL lock. */
3645 static HRESULT IWineD3DSurfaceImpl_BltOverride(IWineD3DSurfaceImpl *dst_surface, const RECT *DestRect,
3646         IWineD3DSurfaceImpl *src_surface, const RECT *SrcRect, DWORD flags, const WINEDDBLTFX *DDBltFx,
3647         WINED3DTEXTUREFILTERTYPE Filter)
3648 {
3649     IWineD3DDeviceImpl *device = dst_surface->resource.device;
3650     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
3651     IWineD3DSwapChainImpl *srcSwapchain = NULL, *dstSwapchain = NULL;
3652     RECT dst_rect, src_rect;
3653
3654     TRACE("dst_surface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, blt_fx %p, filter %s.\n",
3655             dst_surface, wine_dbgstr_rect(DestRect), src_surface, wine_dbgstr_rect(SrcRect),
3656             flags, DDBltFx, debug_d3dtexturefiltertype(Filter));
3657
3658     /* Get the swapchain. One of the surfaces has to be a primary surface */
3659     if (dst_surface->resource.pool == WINED3DPOOL_SYSTEMMEM)
3660     {
3661         WARN("Destination is in sysmem, rejecting gl blt\n");
3662         return WINED3DERR_INVALIDCALL;
3663     }
3664
3665     if (dst_surface->container.type == WINED3D_CONTAINER_SWAPCHAIN)
3666         dstSwapchain = dst_surface->container.u.swapchain;
3667
3668     if (src_surface)
3669     {
3670         if (src_surface->resource.pool == WINED3DPOOL_SYSTEMMEM)
3671         {
3672             WARN("Src is in sysmem, rejecting gl blt\n");
3673             return WINED3DERR_INVALIDCALL;
3674         }
3675
3676         if (src_surface->container.type == WINED3D_CONTAINER_SWAPCHAIN)
3677             srcSwapchain = src_surface->container.u.swapchain;
3678     }
3679
3680     /* Early sort out of cases where no render target is used */
3681     if (!dstSwapchain && !srcSwapchain
3682             && src_surface != device->render_targets[0]
3683             && dst_surface != device->render_targets[0])
3684     {
3685         TRACE("No surface is render target, not using hardware blit.\n");
3686         return WINED3DERR_INVALIDCALL;
3687     }
3688
3689     /* No destination color keying supported */
3690     if (flags & (WINEDDBLT_KEYDEST | WINEDDBLT_KEYDESTOVERRIDE))
3691     {
3692         /* Can we support that with glBlendFunc if blitting to the frame buffer? */
3693         TRACE("Destination color key not supported in accelerated Blit, falling back to software\n");
3694         return WINED3DERR_INVALIDCALL;
3695     }
3696
3697     surface_get_rect(dst_surface, DestRect, &dst_rect);
3698     if (src_surface) surface_get_rect(src_surface, SrcRect, &src_rect);
3699
3700     /* The only case where both surfaces on a swapchain are supported is a back buffer -> front buffer blit on the same swapchain */
3701     if (dstSwapchain && dstSwapchain == srcSwapchain && dstSwapchain->back_buffers
3702             && dst_surface == dstSwapchain->front_buffer
3703             && src_surface == dstSwapchain->back_buffers[0])
3704     {
3705         /* Half-Life does a Blt from the back buffer to the front buffer,
3706          * Full surface size, no flags... Use present instead
3707          *
3708          * This path will only be entered for d3d7 and ddraw apps, because d3d8/9 offer no way to blit TO the front buffer
3709          */
3710
3711         /* Check rects - IWineD3DDevice_Present doesn't handle them */
3712         while(1)
3713         {
3714             TRACE("Looking if a Present can be done...\n");
3715             /* Source Rectangle must be full surface */
3716             if (src_rect.left || src_rect.top
3717                     || src_rect.right != src_surface->resource.width
3718                     || src_rect.bottom != src_surface->resource.height)
3719             {
3720                 TRACE("No, Source rectangle doesn't match\n");
3721                 break;
3722             }
3723
3724             /* No stretching may occur */
3725             if(src_rect.right != dst_rect.right - dst_rect.left ||
3726                src_rect.bottom != dst_rect.bottom - dst_rect.top) {
3727                 TRACE("No, stretching is done\n");
3728                 break;
3729             }
3730
3731             /* Destination must be full surface or match the clipping rectangle */
3732             if (dst_surface->clipper && dst_surface->clipper->hWnd)
3733             {
3734                 RECT cliprect;
3735                 POINT pos[2];
3736                 GetClientRect(dst_surface->clipper->hWnd, &cliprect);
3737                 pos[0].x = dst_rect.left;
3738                 pos[0].y = dst_rect.top;
3739                 pos[1].x = dst_rect.right;
3740                 pos[1].y = dst_rect.bottom;
3741                 MapWindowPoints(GetDesktopWindow(), dst_surface->clipper->hWnd, pos, 2);
3742
3743                 if(pos[0].x != cliprect.left  || pos[0].y != cliprect.top   ||
3744                    pos[1].x != cliprect.right || pos[1].y != cliprect.bottom)
3745                 {
3746                     TRACE("No, dest rectangle doesn't match(clipper)\n");
3747                     TRACE("Clip rect at %s\n", wine_dbgstr_rect(&cliprect));
3748                     TRACE("Blt dest: %s\n", wine_dbgstr_rect(&dst_rect));
3749                     break;
3750                 }
3751             }
3752             else if (dst_rect.left || dst_rect.top
3753                     || dst_rect.right != dst_surface->resource.width
3754                     || dst_rect.bottom != dst_surface->resource.height)
3755             {
3756                 TRACE("No, dest rectangle doesn't match(surface size)\n");
3757                 break;
3758             }
3759
3760             TRACE("Yes\n");
3761
3762             /* These flags are unimportant for the flag check, remove them */
3763             if (!(flags & ~(WINEDDBLT_DONOTWAIT | WINEDDBLT_WAIT)))
3764             {
3765                 WINED3DSWAPEFFECT orig_swap = dstSwapchain->presentParms.SwapEffect;
3766
3767                 /* The idea behind this is that a glReadPixels and a glDrawPixels call
3768                     * take very long, while a flip is fast.
3769                     * This applies to Half-Life, which does such Blts every time it finished
3770                     * a frame, and to Prince of Persia 3D, which uses this to draw at least the main
3771                     * menu. This is also used by all apps when they do windowed rendering
3772                     *
3773                     * The problem is that flipping is not really the same as copying. After a
3774                     * Blt the front buffer is a copy of the back buffer, and the back buffer is
3775                     * untouched. Therefore it's necessary to override the swap effect
3776                     * and to set it back after the flip.
3777                     *
3778                     * Windowed Direct3D < 7 apps do the same. The D3D7 sdk demos are nice
3779                     * testcases.
3780                     */
3781
3782                 dstSwapchain->presentParms.SwapEffect = WINED3DSWAPEFFECT_COPY;
3783                 dstSwapchain->presentParms.PresentationInterval = WINED3DPRESENT_INTERVAL_IMMEDIATE;
3784
3785                 TRACE("Full screen back buffer -> front buffer blt, performing a flip instead\n");
3786                 IWineD3DSwapChain_Present((IWineD3DSwapChain *)dstSwapchain,
3787                         NULL, NULL, dstSwapchain->win_handle, NULL, 0);
3788
3789                 dstSwapchain->presentParms.SwapEffect = orig_swap;
3790
3791                 return WINED3D_OK;
3792             }
3793             break;
3794         }
3795
3796         TRACE("Unsupported blit between buffers on the same swapchain\n");
3797         return WINED3DERR_INVALIDCALL;
3798     } else if(dstSwapchain && dstSwapchain == srcSwapchain) {
3799         FIXME("Implement hardware blit between two surfaces on the same swapchain\n");
3800         return WINED3DERR_INVALIDCALL;
3801     } else if(dstSwapchain && srcSwapchain) {
3802         FIXME("Implement hardware blit between two different swapchains\n");
3803         return WINED3DERR_INVALIDCALL;
3804     }
3805     else if (dstSwapchain)
3806     {
3807         /* Handled with regular texture -> swapchain blit */
3808         if (src_surface == device->render_targets[0])
3809             TRACE("Blit from active render target to a swapchain\n");
3810     }
3811     else if (srcSwapchain && dst_surface == device->render_targets[0])
3812     {
3813         FIXME("Implement blit from a swapchain to the active render target\n");
3814         return WINED3DERR_INVALIDCALL;
3815     }
3816
3817     if ((srcSwapchain || src_surface == device->render_targets[0]) && !dstSwapchain)
3818     {
3819         /* Blit from render target to texture */
3820         BOOL stretchx;
3821
3822         /* P8 read back is not implemented */
3823         if (src_surface->resource.format->id == WINED3DFMT_P8_UINT
3824                 || dst_surface->resource.format->id == WINED3DFMT_P8_UINT)
3825         {
3826             TRACE("P8 read back not supported by frame buffer to texture blit\n");
3827             return WINED3DERR_INVALIDCALL;
3828         }
3829
3830         if (flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3831         {
3832             TRACE("Color keying not supported by frame buffer to texture blit\n");
3833             return WINED3DERR_INVALIDCALL;
3834             /* Destination color key is checked above */
3835         }
3836
3837         if(dst_rect.right - dst_rect.left != src_rect.right - src_rect.left) {
3838             stretchx = TRUE;
3839         } else {
3840             stretchx = FALSE;
3841         }
3842
3843         /* Blt is a pretty powerful call, while glCopyTexSubImage2D is not. glCopyTexSubImage cannot
3844          * flip the image nor scale it.
3845          *
3846          * -> If the app asks for a unscaled, upside down copy, just perform one glCopyTexSubImage2D call
3847          * -> If the app wants a image width an unscaled width, copy it line per line
3848          * -> If the app wants a image that is scaled on the x axis, and the destination rectangle is smaller
3849          *    than the frame buffer, draw an upside down scaled image onto the fb, read it back and restore the
3850          *    back buffer. This is slower than reading line per line, thus not used for flipping
3851          * -> If the app wants a scaled image with a dest rect that is bigger than the fb, it has to be copied
3852          *    pixel by pixel
3853          *
3854          * If EXT_framebuffer_blit is supported that can be used instead. Note that EXT_framebuffer_blit implies
3855          * FBO support, so it doesn't really make sense to try and make it work with different offscreen rendering
3856          * backends. */
3857         if (fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
3858                 &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format,
3859                 &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format))
3860         {
3861             surface_blt_fbo(device, Filter,
3862                     src_surface, SFLAG_INDRAWABLE, &src_rect,
3863                     dst_surface, SFLAG_INDRAWABLE, &dst_rect);
3864             surface_modify_location(dst_surface, SFLAG_INDRAWABLE, TRUE);
3865         }
3866         else if (!stretchx || dst_rect.right - dst_rect.left > src_surface->resource.width
3867                 || dst_rect.bottom - dst_rect.top > src_surface->resource.height)
3868         {
3869             TRACE("No stretching in x direction, using direct framebuffer -> texture copy\n");
3870             fb_copy_to_texture_direct(dst_surface, src_surface, &src_rect, &dst_rect, Filter);
3871         } else {
3872             TRACE("Using hardware stretching to flip / stretch the texture\n");
3873             fb_copy_to_texture_hwstretch(dst_surface, src_surface, &src_rect, &dst_rect, Filter);
3874         }
3875
3876         if (!(dst_surface->flags & SFLAG_DONOTFREE))
3877         {
3878             HeapFree(GetProcessHeap(), 0, dst_surface->resource.heapMemory);
3879             dst_surface->resource.allocatedMemory = NULL;
3880             dst_surface->resource.heapMemory = NULL;
3881         }
3882         else
3883         {
3884             dst_surface->flags &= ~SFLAG_INSYSMEM;
3885         }
3886
3887         return WINED3D_OK;
3888     }
3889     else if (src_surface)
3890     {
3891         /* Blit from offscreen surface to render target */
3892         DWORD oldCKeyFlags = src_surface->CKeyFlags;
3893         WINEDDCOLORKEY oldBltCKey = src_surface->SrcBltCKey;
3894
3895         TRACE("Blt from surface %p to rendertarget %p\n", src_surface, dst_surface);
3896
3897         if (!(flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3898                 && fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
3899                         &src_rect, src_surface->resource.usage, src_surface->resource.pool,
3900                         src_surface->resource.format,
3901                         &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool,
3902                         dst_surface->resource.format))
3903         {
3904             TRACE("Using surface_blt_fbo.\n");
3905             /* The source is always a texture, but never the currently active render target, and the texture
3906              * contents are never upside down. */
3907             surface_blt_fbo(device, Filter,
3908                     src_surface, SFLAG_INDRAWABLE, &src_rect,
3909                     dst_surface, SFLAG_INDRAWABLE, &dst_rect);
3910             surface_modify_location(dst_surface, SFLAG_INDRAWABLE, TRUE);
3911             return WINED3D_OK;
3912         }
3913
3914         if (!(flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE))
3915                 && arbfp_blit.blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
3916                         &src_rect, src_surface->resource.usage, src_surface->resource.pool,
3917                         src_surface->resource.format,
3918                         &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool,
3919                         dst_surface->resource.format))
3920         {
3921             return arbfp_blit_surface(device, src_surface, &src_rect, dst_surface, &dst_rect,
3922                     WINED3D_BLIT_OP_COLOR_BLIT, Filter);
3923         }
3924
3925         if (!device->blitter->blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
3926                 &src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format,
3927                 &dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format))
3928         {
3929             FIXME("Unsupported blit operation falling back to software\n");
3930             return WINED3DERR_INVALIDCALL;
3931         }
3932
3933         /* Color keying: Check if we have to do a color keyed blt,
3934          * and if not check if a color key is activated.
3935          *
3936          * Just modify the color keying parameters in the surface and restore them afterwards
3937          * The surface keeps track of the color key last used to load the opengl surface.
3938          * PreLoad will catch the change to the flags and color key and reload if necessary.
3939          */
3940         if (flags & WINEDDBLT_KEYSRC)
3941         {
3942             /* Use color key from surface */
3943         }
3944         else if (flags & WINEDDBLT_KEYSRCOVERRIDE)
3945         {
3946             /* Use color key from DDBltFx */
3947             src_surface->CKeyFlags |= WINEDDSD_CKSRCBLT;
3948             src_surface->SrcBltCKey = DDBltFx->ddckSrcColorkey;
3949         }
3950         else
3951         {
3952             /* Do not use color key */
3953             src_surface->CKeyFlags &= ~WINEDDSD_CKSRCBLT;
3954         }
3955
3956         surface_blt_to_drawable(device, Filter, flags & (WINEDDBLT_KEYSRC | WINEDDBLT_KEYSRCOVERRIDE),
3957                 src_surface, &src_rect, dst_surface, &dst_rect);
3958
3959         /* Restore the color key parameters */
3960         src_surface->CKeyFlags = oldCKeyFlags;
3961         src_surface->SrcBltCKey = oldBltCKey;
3962
3963         surface_modify_location(dst_surface, SFLAG_INDRAWABLE, TRUE);
3964
3965         return WINED3D_OK;
3966     }
3967     else
3968     {
3969         /* Source-Less Blit to render target */
3970         if (flags & WINEDDBLT_COLORFILL)
3971         {
3972             WINED3DCOLORVALUE color;
3973
3974             TRACE("Colorfill\n");
3975
3976             /* The color as given in the Blt function is in the surface format. */
3977             if (!surface_convert_color_to_float(dst_surface, DDBltFx->u5.dwFillColor, &color))
3978                 return WINED3DERR_INVALIDCALL;
3979
3980             return surface_color_fill(dst_surface, &dst_rect, &color);
3981         }
3982     }
3983
3984     /* Default: Fall back to the generic blt. Not an error, a TRACE is enough */
3985     TRACE("Didn't find any usable render target setup for hw blit, falling back to software\n");
3986     return WINED3DERR_INVALIDCALL;
3987 }
3988
3989 /* Do not call while under the GL lock. */
3990 static HRESULT wined3d_surface_depth_fill(IWineD3DSurfaceImpl *surface, const RECT *rect, float depth)
3991 {
3992     const struct wined3d_resource *resource = &surface->resource;
3993     IWineD3DDeviceImpl *device = resource->device;
3994     const struct blit_shader *blitter;
3995
3996     blitter = wined3d_select_blitter(&device->adapter->gl_info, WINED3D_BLIT_OP_DEPTH_FILL,
3997             NULL, 0, 0, NULL, rect, resource->usage, resource->pool, resource->format);
3998     if (!blitter)
3999     {
4000         FIXME("No blitter is capable of performing the requested depth fill operation.\n");
4001         return WINED3DERR_INVALIDCALL;
4002     }
4003
4004     return blitter->depth_fill(device, surface, rect, depth);
4005 }
4006
4007 static HRESULT wined3d_surface_depth_blt(IWineD3DSurfaceImpl *src_surface, const RECT *src_rect,
4008         IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect)
4009 {
4010     IWineD3DDeviceImpl *device = src_surface->resource.device;
4011
4012     if (!fbo_blit_supported(&device->adapter->gl_info, WINED3D_BLIT_OP_DEPTH_BLIT,
4013             src_rect, src_surface->resource.usage, src_surface->resource.pool, src_surface->resource.format,
4014             dst_rect, dst_surface->resource.usage, dst_surface->resource.pool, dst_surface->resource.format))
4015         return WINED3DERR_INVALIDCALL;
4016
4017     wined3d_surface_depth_blt_fbo(device, src_surface, src_rect, dst_surface, dst_rect);
4018
4019     surface_modify_ds_location(dst_surface, SFLAG_DS_OFFSCREEN,
4020             dst_surface->ds_current_size.cx, dst_surface->ds_current_size.cy);
4021     surface_modify_location(dst_surface, SFLAG_INDRAWABLE, TRUE);
4022
4023     return WINED3D_OK;
4024 }
4025
4026 /* Do not call while under the GL lock. */
4027 static HRESULT WINAPI IWineD3DSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect,
4028         IWineD3DSurface *src_surface, const RECT *SrcRect, DWORD flags,
4029         const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter)
4030 {
4031     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4032     IWineD3DSurfaceImpl *src = (IWineD3DSurfaceImpl *)src_surface;
4033     IWineD3DDeviceImpl *device = This->resource.device;
4034     DWORD src_ds_flags, dst_ds_flags;
4035
4036     TRACE("iface %p, dst_rect %s, src_surface %p, src_rect %s, flags %#x, fx %p, filter %s.\n",
4037             iface, wine_dbgstr_rect(DestRect), src_surface, wine_dbgstr_rect(SrcRect),
4038             flags, DDBltFx, debug_d3dtexturefiltertype(Filter));
4039     TRACE("Usage is %s.\n", debug_d3dusage(This->resource.usage));
4040
4041     if ((This->flags & SFLAG_LOCKED) || (src && (src->flags & SFLAG_LOCKED)))
4042     {
4043         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
4044         return WINEDDERR_SURFACEBUSY;
4045     }
4046
4047     dst_ds_flags = This->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
4048     if (src)
4049         src_ds_flags = src->resource.format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL);
4050     else
4051         src_ds_flags = 0;
4052
4053     if (src_ds_flags || dst_ds_flags)
4054     {
4055         if (flags & WINEDDBLT_DEPTHFILL)
4056         {
4057             float depth;
4058             RECT rect;
4059
4060             TRACE("Depth fill.\n");
4061
4062             surface_get_rect(This, DestRect, &rect);
4063
4064             if (!surface_convert_depth_to_float(This, DDBltFx->u5.dwFillDepth, &depth))
4065                 return WINED3DERR_INVALIDCALL;
4066
4067             if (SUCCEEDED(wined3d_surface_depth_fill(This, &rect, depth)))
4068                 return WINED3D_OK;
4069         }
4070         else
4071         {
4072             RECT src_rect, dst_rect;
4073
4074             /* Accessing depth / stencil surfaces is supposed to fail while in
4075              * a scene, except for fills, which seem to work. */
4076             if (device->inScene)
4077             {
4078                 WARN("Rejecting depth / stencil access while in scene.\n");
4079                 return WINED3DERR_INVALIDCALL;
4080             }
4081
4082             if (src_ds_flags != dst_ds_flags)
4083             {
4084                 WARN("Rejecting depth / stencil blit between incompatible formats.\n");
4085                 return WINED3DERR_INVALIDCALL;
4086             }
4087
4088             if (SrcRect && (SrcRect->top || SrcRect->left
4089                     || SrcRect->bottom != src->resource.height
4090                     || SrcRect->right != src->resource.width))
4091             {
4092                 WARN("Rejecting depth / stencil blit with invalid source rect %s.\n",
4093                         wine_dbgstr_rect(SrcRect));
4094                 return WINED3DERR_INVALIDCALL;
4095             }
4096
4097             if (DestRect && (DestRect->top || DestRect->left
4098                     || DestRect->bottom != This->resource.height
4099                     || DestRect->right != This->resource.width))
4100             {
4101                 WARN("Rejecting depth / stencil blit with invalid destination rect %s.\n",
4102                         wine_dbgstr_rect(SrcRect));
4103                 return WINED3DERR_INVALIDCALL;
4104             }
4105
4106             if (src->resource.height != This->resource.height
4107                     || src->resource.width != This->resource.width)
4108             {
4109                 WARN("Rejecting depth / stencil blit with mismatched surface sizes.\n");
4110                 return WINED3DERR_INVALIDCALL;
4111             }
4112
4113             surface_get_rect(src, SrcRect, &src_rect);
4114             surface_get_rect(This, DestRect, &dst_rect);
4115
4116             if (SUCCEEDED(wined3d_surface_depth_blt(src, &src_rect, This, &dst_rect)))
4117                 return WINED3D_OK;
4118         }
4119     }
4120
4121     /* Special cases for RenderTargets */
4122     if ((This->resource.usage & WINED3DUSAGE_RENDERTARGET)
4123             || (src && (src->resource.usage & WINED3DUSAGE_RENDERTARGET)))
4124     {
4125         if (SUCCEEDED(IWineD3DSurfaceImpl_BltOverride(This, DestRect, src, SrcRect, flags, DDBltFx, Filter)))
4126             return WINED3D_OK;
4127     }
4128
4129     /* For the rest call the X11 surface implementation.
4130      * For RenderTargets this should be implemented OpenGL accelerated in BltOverride,
4131      * other Blts are rather rare. */
4132     return IWineD3DBaseSurfaceImpl_Blt(iface, DestRect, src_surface, SrcRect, flags, DDBltFx, Filter);
4133 }
4134
4135 static HRESULT WINAPI IWineD3DSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
4136         IWineD3DSurface *src_surface, const RECT *rsrc, DWORD trans)
4137 {
4138     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *)iface;
4139     IWineD3DSurfaceImpl *src = (IWineD3DSurfaceImpl *)src_surface;
4140     IWineD3DDeviceImpl *device = This->resource.device;
4141
4142     TRACE("iface %p, dst_x %u, dst_y %u, src_surface %p, src_rect %s, flags %#x.\n",
4143             iface, dstx, dsty, src_surface, wine_dbgstr_rect(rsrc), trans);
4144
4145     if ((This->flags & SFLAG_LOCKED) || (src->flags & SFLAG_LOCKED))
4146     {
4147         WARN(" Surface is busy, returning DDERR_SURFACEBUSY\n");
4148         return WINEDDERR_SURFACEBUSY;
4149     }
4150
4151     if (device->inScene && (This == device->depth_stencil || src == device->depth_stencil))
4152     {
4153         TRACE("Attempt to access the depth stencil surface in a BeginScene / EndScene pair, returning WINED3DERR_INVALIDCALL\n");
4154         return WINED3DERR_INVALIDCALL;
4155     }
4156
4157     /* Special cases for RenderTargets */
4158     if ((This->resource.usage & WINED3DUSAGE_RENDERTARGET)
4159             || (src->resource.usage & WINED3DUSAGE_RENDERTARGET))
4160     {
4161
4162         RECT SrcRect, DstRect;
4163         DWORD flags = 0;
4164
4165         surface_get_rect(src, rsrc, &SrcRect);
4166
4167         DstRect.left = dstx;
4168         DstRect.top=dsty;
4169         DstRect.right = dstx + SrcRect.right - SrcRect.left;
4170         DstRect.bottom = dsty + SrcRect.bottom - SrcRect.top;
4171
4172         /* Convert BltFast flags into Btl ones because it is called from SurfaceImpl_Blt as well */
4173         if (trans & WINEDDBLTFAST_SRCCOLORKEY)
4174             flags |= WINEDDBLT_KEYSRC;
4175         if (trans & WINEDDBLTFAST_DESTCOLORKEY)
4176             flags |= WINEDDBLT_KEYDEST;
4177         if (trans & WINEDDBLTFAST_WAIT)
4178             flags |= WINEDDBLT_WAIT;
4179         if (trans & WINEDDBLTFAST_DONOTWAIT)
4180             flags |= WINEDDBLT_DONOTWAIT;
4181
4182         if (SUCCEEDED(IWineD3DSurfaceImpl_BltOverride(This,
4183                 &DstRect, src, &SrcRect, flags, NULL, WINED3DTEXF_POINT)))
4184             return WINED3D_OK;
4185     }
4186
4187     return IWineD3DBaseSurfaceImpl_BltFast(iface, dstx, dsty, src_surface, rsrc, trans);
4188 }
4189
4190 static HRESULT WINAPI IWineD3DSurfaceImpl_PrivateSetup(IWineD3DSurface *iface) {
4191     /** Check against the maximum texture sizes supported by the video card **/
4192     IWineD3DSurfaceImpl *This = (IWineD3DSurfaceImpl *) iface;
4193     const struct wined3d_gl_info *gl_info = &This->resource.device->adapter->gl_info;
4194     unsigned int pow2Width, pow2Height;
4195
4196     This->surface_ops = &surface_ops;
4197
4198     This->texture_name = 0;
4199     This->texture_target = GL_TEXTURE_2D;
4200
4201     /* Non-power2 support */
4202     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] || gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
4203     {
4204         pow2Width = This->resource.width;
4205         pow2Height = This->resource.height;
4206     }
4207     else
4208     {
4209         /* Find the nearest pow2 match */
4210         pow2Width = pow2Height = 1;
4211         while (pow2Width < This->resource.width) pow2Width <<= 1;
4212         while (pow2Height < This->resource.height) pow2Height <<= 1;
4213     }
4214     This->pow2Width  = pow2Width;
4215     This->pow2Height = pow2Height;
4216
4217     if (pow2Width > This->resource.width || pow2Height > This->resource.height)
4218     {
4219         /* TODO: Add support for non power two compressed textures. */
4220         if (This->resource.format->flags & WINED3DFMT_FLAG_COMPRESSED)
4221         {
4222             FIXME("(%p) Compressed non-power-two textures are not supported w(%d) h(%d)\n",
4223                   This, This->resource.width, This->resource.height);
4224             return WINED3DERR_NOTAVAILABLE;
4225         }
4226     }
4227
4228     if (pow2Width != This->resource.width
4229             || pow2Height != This->resource.height)
4230     {
4231         This->flags |= SFLAG_NONPOW2;
4232     }
4233
4234     TRACE("%p\n", This);
4235     if ((This->pow2Width > gl_info->limits.texture_size || This->pow2Height > gl_info->limits.texture_size)
4236             && !(This->resource.usage & (WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL)))
4237     {
4238         /* one of three options
4239         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)
4240         2: Set the texture to the maximum size (bad idea)
4241         3:    WARN and return WINED3DERR_NOTAVAILABLE;
4242         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.
4243         */
4244         if(This->resource.pool == WINED3DPOOL_DEFAULT || This->resource.pool == WINED3DPOOL_MANAGED)
4245         {
4246             WARN("(%p) Unable to allocate a surface which exceeds the maximum OpenGL texture size\n", This);
4247             return WINED3DERR_NOTAVAILABLE;
4248         }
4249
4250         /* We should never use this surface in combination with OpenGL! */
4251         TRACE("(%p) Creating an oversized surface: %ux%u\n", This, This->pow2Width, This->pow2Height);
4252     }
4253     else
4254     {
4255         /* Don't use ARB_TEXTURE_RECTANGLE in case the surface format is P8 and EXT_PALETTED_TEXTURE
4256            is used in combination with texture uploads (RTL_READTEX/RTL_TEXTEX). The reason is that EXT_PALETTED_TEXTURE
4257            doesn't work in combination with ARB_TEXTURE_RECTANGLE.
4258         */
4259         if (This->flags & SFLAG_NONPOW2 && gl_info->supported[ARB_TEXTURE_RECTANGLE]
4260                 && !(This->resource.format->id == WINED3DFMT_P8_UINT
4261                 && gl_info->supported[EXT_PALETTED_TEXTURE]
4262                 && wined3d_settings.rendertargetlock_mode == RTL_READTEX))
4263         {
4264             This->texture_target = GL_TEXTURE_RECTANGLE_ARB;
4265             This->pow2Width  = This->resource.width;
4266             This->pow2Height = This->resource.height;
4267             This->flags &= ~(SFLAG_NONPOW2 | SFLAG_NORMCOORD);
4268         }
4269     }
4270
4271     switch (wined3d_settings.offscreen_rendering_mode)
4272     {
4273         case ORM_FBO:
4274             This->get_drawable_size = get_drawable_size_fbo;
4275             break;
4276
4277         case ORM_BACKBUFFER:
4278             This->get_drawable_size = get_drawable_size_backbuffer;
4279             break;
4280
4281         default:
4282             ERR("Unhandled offscreen rendering mode %#x.\n", wined3d_settings.offscreen_rendering_mode);
4283             return WINED3DERR_INVALIDCALL;
4284     }
4285
4286     This->flags |= SFLAG_INSYSMEM;
4287
4288     return WINED3D_OK;
4289 }
4290
4291 /* GL locking is done by the caller */
4292 static void surface_depth_blt(IWineD3DSurfaceImpl *This, const struct wined3d_gl_info *gl_info,
4293         GLuint texture, GLsizei w, GLsizei h, GLenum target)
4294 {
4295     IWineD3DDeviceImpl *device = This->resource.device;
4296     GLint compare_mode = GL_NONE;
4297     struct blt_info info;
4298     GLint old_binding = 0;
4299     RECT rect;
4300
4301     glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT | GL_VIEWPORT_BIT);
4302
4303     glDisable(GL_CULL_FACE);
4304     glDisable(GL_BLEND);
4305     glDisable(GL_ALPHA_TEST);
4306     glDisable(GL_SCISSOR_TEST);
4307     glDisable(GL_STENCIL_TEST);
4308     glEnable(GL_DEPTH_TEST);
4309     glDepthFunc(GL_ALWAYS);
4310     glDepthMask(GL_TRUE);
4311     glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
4312     glViewport(0, This->pow2Height - h, w, h);
4313
4314     SetRect(&rect, 0, h, w, 0);
4315     surface_get_blt_info(target, &rect, This->pow2Width, This->pow2Height, &info);
4316     GL_EXTCALL(glActiveTextureARB(GL_TEXTURE0_ARB));
4317     glGetIntegerv(info.binding, &old_binding);
4318     glBindTexture(info.bind_target, texture);
4319     if (gl_info->supported[ARB_SHADOW])
4320     {
4321         glGetTexParameteriv(info.bind_target, GL_TEXTURE_COMPARE_MODE_ARB, &compare_mode);
4322         if (compare_mode != GL_NONE) glTexParameteri(info.bind_target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);
4323     }
4324
4325     device->shader_backend->shader_select_depth_blt(device->shader_priv,
4326             gl_info, info.tex_type, &This->ds_current_size);
4327
4328     glBegin(GL_TRIANGLE_STRIP);
4329     glTexCoord3fv(info.coords[0]);
4330     glVertex2f(-1.0f, -1.0f);
4331     glTexCoord3fv(info.coords[1]);
4332     glVertex2f(1.0f, -1.0f);
4333     glTexCoord3fv(info.coords[2]);
4334     glVertex2f(-1.0f, 1.0f);
4335     glTexCoord3fv(info.coords[3]);
4336     glVertex2f(1.0f, 1.0f);
4337     glEnd();
4338
4339     if (compare_mode != GL_NONE) glTexParameteri(info.bind_target, GL_TEXTURE_COMPARE_MODE_ARB, compare_mode);
4340     glBindTexture(info.bind_target, old_binding);
4341
4342     glPopAttrib();
4343
4344     device->shader_backend->shader_deselect_depth_blt(device->shader_priv, gl_info);
4345 }
4346
4347 void surface_modify_ds_location(IWineD3DSurfaceImpl *surface,
4348         DWORD location, UINT w, UINT h)
4349 {
4350     TRACE("surface %p, new location %#x, w %u, h %u.\n", surface, location, w, h);
4351
4352     if (location & ~SFLAG_DS_LOCATIONS)
4353         FIXME("Invalid location (%#x) specified.\n", location);
4354
4355     surface->ds_current_size.cx = w;
4356     surface->ds_current_size.cy = h;
4357     surface->flags &= ~SFLAG_DS_LOCATIONS;
4358     surface->flags |= location;
4359 }
4360
4361 /* Context activation is done by the caller. */
4362 void surface_load_ds_location(IWineD3DSurfaceImpl *surface, struct wined3d_context *context, DWORD location)
4363 {
4364     IWineD3DDeviceImpl *device = surface->resource.device;
4365     const struct wined3d_gl_info *gl_info = context->gl_info;
4366     GLsizei w, h;
4367
4368     TRACE("surface %p, new location %#x.\n", surface, location);
4369
4370     /* TODO: Make this work for modes other than FBO */
4371     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return;
4372
4373     if (!(surface->flags & location))
4374     {
4375         w = surface->ds_current_size.cx;
4376         h = surface->ds_current_size.cy;
4377         surface->ds_current_size.cx = 0;
4378         surface->ds_current_size.cy = 0;
4379     }
4380     else
4381     {
4382         w = surface->resource.width;
4383         h = surface->resource.height;
4384     }
4385
4386     if (surface->ds_current_size.cx == surface->resource.width
4387             && surface->ds_current_size.cy == surface->resource.height)
4388     {
4389         TRACE("Location (%#x) is already up to date.\n", location);
4390         return;
4391     }
4392
4393     if (surface->current_renderbuffer)
4394     {
4395         FIXME("Not supported with fixed up depth stencil.\n");
4396         return;
4397     }
4398
4399     if (!(surface->flags & SFLAG_LOCATIONS))
4400     {
4401         FIXME("No up to date depth stencil location.\n");
4402         surface->flags |= location;
4403         return;
4404     }
4405
4406     if (location == SFLAG_DS_OFFSCREEN)
4407     {
4408         GLint old_binding = 0;
4409         GLenum bind_target;
4410
4411         /* The render target is allowed to be smaller than the depth/stencil
4412          * buffer, so the onscreen depth/stencil buffer is potentially smaller
4413          * than the offscreen surface. Don't overwrite the offscreen surface
4414          * with undefined data. */
4415         w = min(w, context->swapchain->presentParms.BackBufferWidth);
4416         h = min(h, context->swapchain->presentParms.BackBufferHeight);
4417
4418         TRACE("Copying onscreen depth buffer to depth texture.\n");
4419
4420         ENTER_GL();
4421
4422         if (!device->depth_blt_texture)
4423         {
4424             glGenTextures(1, &device->depth_blt_texture);
4425         }
4426
4427         /* Note that we use depth_blt here as well, rather than glCopyTexImage2D
4428          * directly on the FBO texture. That's because we need to flip. */
4429         context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4430         if (surface->texture_target == GL_TEXTURE_RECTANGLE_ARB)
4431         {
4432             glGetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB, &old_binding);
4433             bind_target = GL_TEXTURE_RECTANGLE_ARB;
4434         }
4435         else
4436         {
4437             glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_binding);
4438             bind_target = GL_TEXTURE_2D;
4439         }
4440         glBindTexture(bind_target, device->depth_blt_texture);
4441         glCopyTexImage2D(bind_target, surface->texture_level, surface->resource.format->glInternal, 0, 0, w, h, 0);
4442         glTexParameteri(bind_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
4443         glTexParameteri(bind_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
4444         glTexParameteri(bind_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
4445         glTexParameteri(bind_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
4446         glTexParameteri(bind_target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
4447         glTexParameteri(bind_target, GL_DEPTH_TEXTURE_MODE_ARB, GL_LUMINANCE);
4448         glBindTexture(bind_target, old_binding);
4449
4450         /* Setup the destination */
4451         if (!device->depth_blt_rb)
4452         {
4453             gl_info->fbo_ops.glGenRenderbuffers(1, &device->depth_blt_rb);
4454             checkGLcall("glGenRenderbuffersEXT");
4455         }
4456         if (device->depth_blt_rb_w != w || device->depth_blt_rb_h != h)
4457         {
4458             gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, device->depth_blt_rb);
4459             checkGLcall("glBindRenderbufferEXT");
4460             gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, w, h);
4461             checkGLcall("glRenderbufferStorageEXT");
4462             device->depth_blt_rb_w = w;
4463             device->depth_blt_rb_h = h;
4464         }
4465
4466         context_bind_fbo(context, GL_FRAMEBUFFER, &context->dst_fbo);
4467         gl_info->fbo_ops.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
4468                 GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, device->depth_blt_rb);
4469         checkGLcall("glFramebufferRenderbufferEXT");
4470         context_attach_depth_stencil_fbo(context, GL_FRAMEBUFFER, surface, FALSE);
4471
4472         /* Do the actual blit */
4473         surface_depth_blt(surface, gl_info, device->depth_blt_texture, w, h, bind_target);
4474         checkGLcall("depth_blt");
4475
4476         if (context->current_fbo) context_bind_fbo(context, GL_FRAMEBUFFER, &context->current_fbo->id);
4477         else context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4478
4479         LEAVE_GL();
4480
4481         if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
4482     }
4483     else if (location == SFLAG_DS_ONSCREEN)
4484     {
4485         TRACE("Copying depth texture to onscreen depth buffer.\n");
4486
4487         ENTER_GL();
4488
4489         context_bind_fbo(context, GL_FRAMEBUFFER, NULL);
4490         surface_depth_blt(surface, gl_info, surface->texture_name,
4491                 w, h, surface->texture_target);
4492         checkGLcall("depth_blt");
4493
4494         if (context->current_fbo) context_bind_fbo(context, GL_FRAMEBUFFER, &context->current_fbo->id);
4495
4496         LEAVE_GL();
4497
4498         if (wined3d_settings.strict_draw_ordering) wglFlush(); /* Flush to ensure ordering across contexts. */
4499     }
4500     else
4501     {
4502         ERR("Invalid location (%#x) specified.\n", location);
4503     }
4504
4505     surface->flags |= location;
4506     surface->ds_current_size.cx = surface->resource.width;
4507     surface->ds_current_size.cy = surface->resource.height;
4508 }
4509
4510 void surface_modify_location(IWineD3DSurfaceImpl *surface, DWORD flag, BOOL persistent)
4511 {
4512     const struct wined3d_gl_info *gl_info = &surface->resource.device->adapter->gl_info;
4513     IWineD3DSurfaceImpl *overlay;
4514
4515     TRACE("surface %p, location %s, persistent %#x.\n",
4516             surface, debug_surflocation(flag), persistent);
4517
4518     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
4519     {
4520         if (surface_is_offscreen(surface))
4521         {
4522             /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4523             if (flag & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)) flag |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4524         }
4525         else
4526         {
4527             TRACE("Surface %p is an onscreen surface.\n", surface);
4528         }
4529     }
4530
4531     if (flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)
4532             && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
4533     {
4534         flag |= (SFLAG_INTEXTURE | SFLAG_INSRGBTEX);
4535     }
4536
4537     if (persistent)
4538     {
4539         if (((surface->flags & SFLAG_INTEXTURE) && !(flag & SFLAG_INTEXTURE))
4540                 || ((surface->flags & SFLAG_INSRGBTEX) && !(flag & SFLAG_INSRGBTEX)))
4541         {
4542             if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
4543             {
4544                 TRACE("Passing to container.\n");
4545                 wined3d_texture_set_dirty(surface->container.u.texture, TRUE);
4546             }
4547         }
4548         surface->flags &= ~SFLAG_LOCATIONS;
4549         surface->flags |= flag;
4550
4551         /* Redraw emulated overlays, if any */
4552         if (flag & SFLAG_INDRAWABLE && !list_empty(&surface->overlays))
4553         {
4554             LIST_FOR_EACH_ENTRY(overlay, &surface->overlays, IWineD3DSurfaceImpl, overlay_entry)
4555             {
4556                 overlay->surface_ops->surface_draw_overlay(overlay);
4557             }
4558         }
4559     }
4560     else
4561     {
4562         if ((surface->flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) && (flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)))
4563         {
4564             if (surface->container.type == WINED3D_CONTAINER_TEXTURE)
4565             {
4566                 TRACE("Passing to container\n");
4567                 wined3d_texture_set_dirty(surface->container.u.texture, TRUE);
4568             }
4569         }
4570         surface->flags &= ~flag;
4571     }
4572
4573     if (!(surface->flags & SFLAG_LOCATIONS))
4574     {
4575         ERR("Surface %p does not have any up to date location.\n", surface);
4576     }
4577 }
4578
4579 HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RECT *rect)
4580 {
4581     IWineD3DDeviceImpl *device = surface->resource.device;
4582     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
4583     BOOL drawable_read_ok = surface_is_offscreen(surface);
4584     struct wined3d_format format;
4585     CONVERT_TYPES convert;
4586     int width, pitch, outpitch;
4587     BYTE *mem;
4588     BOOL in_fbo = FALSE;
4589
4590     TRACE("surface %p, location %s, rect %s.\n", surface, debug_surflocation(flag), wine_dbgstr_rect(rect));
4591
4592     if (surface->resource.usage & WINED3DUSAGE_DEPTHSTENCIL)
4593     {
4594         if (flag == SFLAG_INTEXTURE)
4595         {
4596             struct wined3d_context *context = context_acquire(device, NULL);
4597             surface_load_ds_location(surface, context, SFLAG_DS_OFFSCREEN);
4598             context_release(context);
4599             return WINED3D_OK;
4600         }
4601         else
4602         {
4603             FIXME("Unimplemented location %s for depth/stencil buffers.\n", debug_surflocation(flag));
4604             return WINED3DERR_INVALIDCALL;
4605         }
4606     }
4607
4608     if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
4609     {
4610         if (surface_is_offscreen(surface))
4611         {
4612             /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets.
4613              * Prefer SFLAG_INTEXTURE. */
4614             if (flag == SFLAG_INDRAWABLE) flag = SFLAG_INTEXTURE;
4615             drawable_read_ok = FALSE;
4616             in_fbo = TRUE;
4617         }
4618         else
4619         {
4620             TRACE("Surface %p is an onscreen surface.\n", surface);
4621         }
4622     }
4623
4624     if (flag == SFLAG_INSRGBTEX && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
4625     {
4626         flag = SFLAG_INTEXTURE;
4627     }
4628
4629     if (surface->flags & flag)
4630     {
4631         TRACE("Location already up to date\n");
4632         return WINED3D_OK;
4633     }
4634
4635     if (!(surface->flags & SFLAG_LOCATIONS))
4636     {
4637         ERR("Surface %p does not have any up to date location.\n", surface);
4638         surface->flags |= SFLAG_LOST;
4639         return WINED3DERR_DEVICELOST;
4640     }
4641
4642     if (flag == SFLAG_INSYSMEM)
4643     {
4644         surface_prepare_system_memory(surface);
4645
4646         /* Download the surface to system memory */
4647         if (surface->flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX))
4648         {
4649             struct wined3d_context *context = NULL;
4650
4651             if (!device->isInDraw) context = context_acquire(device, NULL);
4652
4653             surface_bind_and_dirtify(surface, gl_info, !(surface->flags & SFLAG_INTEXTURE));
4654             surface_download_data(surface, gl_info);
4655
4656             if (context) context_release(context);
4657         }
4658         else
4659         {
4660             /* Note: It might be faster to download into a texture first. */
4661             read_from_framebuffer(surface, rect, surface->resource.allocatedMemory,
4662                     IWineD3DSurface_GetPitch((IWineD3DSurface *)surface));
4663         }
4664     }
4665     else if (flag == SFLAG_INDRAWABLE)
4666     {
4667         if (wined3d_settings.rendertargetlock_mode == RTL_READTEX)
4668             surface_load_location(surface, SFLAG_INTEXTURE, NULL);
4669
4670         if (surface->flags & SFLAG_INTEXTURE)
4671         {
4672             RECT r;
4673
4674             surface_get_rect(surface, rect, &r);
4675             surface_blt_to_drawable(device, WINED3DTEXF_POINT, FALSE, surface, &r, surface, &r);
4676         }
4677         else
4678         {
4679             int byte_count;
4680             if ((surface->flags & SFLAG_LOCATIONS) == SFLAG_INSRGBTEX)
4681             {
4682                 /* This needs a shader to convert the srgb data sampled from the GL texture into RGB
4683                  * values, otherwise we get incorrect values in the target. For now go the slow way
4684                  * via a system memory copy
4685                  */
4686                 surface_load_location(surface, SFLAG_INSYSMEM, rect);
4687             }
4688
4689             d3dfmt_get_conv(surface, FALSE /* We need color keying */,
4690                     FALSE /* We won't use textures */, &format, &convert);
4691
4692             /* The width is in 'length' not in bytes */
4693             width = surface->resource.width;
4694             pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *)surface);
4695
4696             /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4697              * but it isn't set (yet) in all cases it is getting called. */
4698             if ((convert != NO_CONVERSION) && (surface->flags & SFLAG_PBO))
4699             {
4700                 struct wined3d_context *context = NULL;
4701
4702                 TRACE("Removing the pbo attached to surface %p.\n", surface);
4703
4704                 if (!device->isInDraw) context = context_acquire(device, NULL);
4705                 surface_remove_pbo(surface, gl_info);
4706                 if (context) context_release(context);
4707             }
4708
4709             if ((convert != NO_CONVERSION) && surface->resource.allocatedMemory)
4710             {
4711                 int height = surface->resource.height;
4712                 byte_count = format.conv_byte_count;
4713
4714                 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4715                 outpitch = width * byte_count;
4716                 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4717
4718                 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4719                 if(!mem) {
4720                     ERR("Out of memory %d, %d!\n", outpitch, height);
4721                     return WINED3DERR_OUTOFVIDEOMEMORY;
4722                 }
4723                 d3dfmt_convert_surface(surface->resource.allocatedMemory, mem, pitch,
4724                         width, height, outpitch, convert, surface);
4725
4726                 surface->flags |= SFLAG_CONVERTED;
4727             }
4728             else
4729             {
4730                 surface->flags &= ~SFLAG_CONVERTED;
4731                 mem = surface->resource.allocatedMemory;
4732                 byte_count = format.byte_count;
4733             }
4734
4735             flush_to_framebuffer_drawpixels(surface, rect, format.glFormat, format.glType, byte_count, mem);
4736
4737             /* Don't delete PBO memory */
4738             if ((mem != surface->resource.allocatedMemory) && !(surface->flags & SFLAG_PBO))
4739                 HeapFree(GetProcessHeap(), 0, mem);
4740         }
4741     }
4742     else /* if(flag & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)) */
4743     {
4744         const DWORD attach_flags = WINED3DFMT_FLAG_FBO_ATTACHABLE | WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB;
4745
4746         if (drawable_read_ok && (surface->flags & SFLAG_INDRAWABLE))
4747         {
4748             read_from_framebuffer_texture(surface, flag == SFLAG_INSRGBTEX);
4749         }
4750         else if (surface->flags & (SFLAG_INSRGBTEX | SFLAG_INTEXTURE)
4751                 && (surface->resource.format->flags & attach_flags) == attach_flags
4752                 && fbo_blit_supported(gl_info, WINED3D_BLIT_OP_COLOR_BLIT,
4753                         NULL, surface->resource.usage, surface->resource.pool, surface->resource.format,
4754                         NULL, surface->resource.usage, surface->resource.pool, surface->resource.format))
4755         {
4756             DWORD src_location = flag == SFLAG_INSRGBTEX ? SFLAG_INTEXTURE : SFLAG_INSRGBTEX;
4757             RECT rect = {0, 0, surface->resource.width, surface->resource.height};
4758
4759             surface_blt_fbo(surface->resource.device, WINED3DTEXF_POINT,
4760                     surface, src_location, &rect, surface, flag, &rect);
4761         }
4762         else
4763         {
4764             /* Upload from system memory */
4765             BOOL srgb = flag == SFLAG_INSRGBTEX;
4766             struct wined3d_context *context = NULL;
4767
4768             d3dfmt_get_conv(surface, TRUE /* We need color keying */,
4769                     TRUE /* We will use textures */, &format, &convert);
4770
4771             if (srgb)
4772             {
4773                 if ((surface->flags & (SFLAG_INTEXTURE | SFLAG_INSYSMEM)) == SFLAG_INTEXTURE)
4774                 {
4775                     /* Performance warning... */
4776                     FIXME("Downloading RGB surface %p to reload it as sRGB.\n", surface);
4777                     surface_load_location(surface, SFLAG_INSYSMEM, rect);
4778                 }
4779             }
4780             else
4781             {
4782                 if ((surface->flags & (SFLAG_INSRGBTEX | SFLAG_INSYSMEM)) == SFLAG_INSRGBTEX)
4783                 {
4784                     /* Performance warning... */
4785                     FIXME("Downloading sRGB surface %p to reload it as RGB.\n", surface);
4786                     surface_load_location(surface, SFLAG_INSYSMEM, rect);
4787                 }
4788             }
4789             if (!(surface->flags & SFLAG_INSYSMEM))
4790             {
4791                 WARN("Trying to load a texture from sysmem, but SFLAG_INSYSMEM is not set.\n");
4792                 /* Lets hope we get it from somewhere... */
4793                 surface_load_location(surface, SFLAG_INSYSMEM, rect);
4794             }
4795
4796             if (!device->isInDraw) context = context_acquire(device, NULL);
4797
4798             surface_prepare_texture(surface, gl_info, srgb);
4799             surface_bind_and_dirtify(surface, gl_info, srgb);
4800
4801             if (surface->CKeyFlags & WINEDDSD_CKSRCBLT)
4802             {
4803                 surface->flags |= SFLAG_GLCKEY;
4804                 surface->glCKey = surface->SrcBltCKey;
4805             }
4806             else surface->flags &= ~SFLAG_GLCKEY;
4807
4808             /* The width is in 'length' not in bytes */
4809             width = surface->resource.width;
4810             pitch = IWineD3DSurface_GetPitch((IWineD3DSurface *)surface);
4811
4812             /* Don't use PBOs for converted surfaces. During PBO conversion we look at SFLAG_CONVERTED
4813              * but it isn't set (yet) in all cases it is getting called. */
4814             if ((convert != NO_CONVERSION || format.convert) && (surface->flags & SFLAG_PBO))
4815             {
4816                 TRACE("Removing the pbo attached to surface %p.\n", surface);
4817                 surface_remove_pbo(surface, gl_info);
4818             }
4819
4820             if (format.convert)
4821             {
4822                 /* This code is entered for texture formats which need a fixup. */
4823                 UINT height = surface->resource.height;
4824
4825                 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4826                 outpitch = width * format.conv_byte_count;
4827                 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4828
4829                 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4830                 if(!mem) {
4831                     ERR("Out of memory %d, %d!\n", outpitch, height);
4832                     if (context) context_release(context);
4833                     return WINED3DERR_OUTOFVIDEOMEMORY;
4834                 }
4835                 format.convert(surface->resource.allocatedMemory, mem, pitch, width, height);
4836             }
4837             else if (convert != NO_CONVERSION && surface->resource.allocatedMemory)
4838             {
4839                 /* This code is only entered for color keying fixups */
4840                 UINT height = surface->resource.height;
4841
4842                 /* Stick to the alignment for the converted surface too, makes it easier to load the surface */
4843                 outpitch = width * format.conv_byte_count;
4844                 outpitch = (outpitch + device->surface_alignment - 1) & ~(device->surface_alignment - 1);
4845
4846                 mem = HeapAlloc(GetProcessHeap(), 0, outpitch * height);
4847                 if(!mem) {
4848                     ERR("Out of memory %d, %d!\n", outpitch, height);
4849                     if (context) context_release(context);
4850                     return WINED3DERR_OUTOFVIDEOMEMORY;
4851                 }
4852                 d3dfmt_convert_surface(surface->resource.allocatedMemory, mem, pitch,
4853                         width, height, outpitch, convert, surface);
4854             }
4855             else
4856             {
4857                 mem = surface->resource.allocatedMemory;
4858             }
4859
4860             /* Make sure the correct pitch is used */
4861             ENTER_GL();
4862             glPixelStorei(GL_UNPACK_ROW_LENGTH, width);
4863             LEAVE_GL();
4864
4865             if (mem || (surface->flags & SFLAG_PBO))
4866                 surface_upload_data(surface, gl_info, &format, srgb, mem);
4867
4868             /* Restore the default pitch */
4869             ENTER_GL();
4870             glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
4871             LEAVE_GL();
4872
4873             if (context) context_release(context);
4874
4875             /* Don't delete PBO memory */
4876             if ((mem != surface->resource.allocatedMemory) && !(surface->flags & SFLAG_PBO))
4877                 HeapFree(GetProcessHeap(), 0, mem);
4878         }
4879     }
4880
4881     if (!rect)
4882     {
4883         surface->flags |= flag;
4884
4885         if (flag != SFLAG_INSYSMEM && (surface->flags & SFLAG_INSYSMEM))
4886             surface_evict_sysmem(surface);
4887     }
4888
4889     if (in_fbo && (surface->flags & (SFLAG_INTEXTURE | SFLAG_INDRAWABLE)))
4890     {
4891         /* With ORM_FBO, SFLAG_INTEXTURE and SFLAG_INDRAWABLE are the same for offscreen targets. */
4892         surface->flags |= (SFLAG_INTEXTURE | SFLAG_INDRAWABLE);
4893     }
4894
4895     if (surface->flags & (SFLAG_INTEXTURE | SFLAG_INSRGBTEX)
4896             && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
4897     {
4898         surface->flags |= (SFLAG_INTEXTURE | SFLAG_INSRGBTEX);
4899     }
4900
4901     return WINED3D_OK;
4902 }
4903
4904 static WINED3DSURFTYPE WINAPI IWineD3DSurfaceImpl_GetImplType(IWineD3DSurface *iface) {
4905     return SURFACE_OPENGL;
4906 }
4907
4908 BOOL surface_is_offscreen(IWineD3DSurfaceImpl *surface)
4909 {
4910     IWineD3DSwapChainImpl *swapchain = surface->container.u.swapchain;
4911
4912     /* Not on a swapchain - must be offscreen */
4913     if (surface->container.type != WINED3D_CONTAINER_SWAPCHAIN) return TRUE;
4914
4915     /* The front buffer is always onscreen */
4916     if (surface == swapchain->front_buffer) return FALSE;
4917
4918     /* If the swapchain is rendered to an FBO, the backbuffer is
4919      * offscreen, otherwise onscreen */
4920     return swapchain->render_to_fbo;
4921 }
4922
4923 const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl =
4924 {
4925     /* IUnknown */
4926     IWineD3DBaseSurfaceImpl_QueryInterface,
4927     IWineD3DBaseSurfaceImpl_AddRef,
4928     IWineD3DSurfaceImpl_Release,
4929     /* IWineD3DResource */
4930     IWineD3DBaseSurfaceImpl_GetParent,
4931     IWineD3DBaseSurfaceImpl_SetPrivateData,
4932     IWineD3DBaseSurfaceImpl_GetPrivateData,
4933     IWineD3DBaseSurfaceImpl_FreePrivateData,
4934     IWineD3DBaseSurfaceImpl_SetPriority,
4935     IWineD3DBaseSurfaceImpl_GetPriority,
4936     IWineD3DSurfaceImpl_PreLoad,
4937     IWineD3DBaseSurfaceImpl_GetType,
4938     /* IWineD3DSurface */
4939     IWineD3DBaseSurfaceImpl_GetResource,
4940     IWineD3DSurfaceImpl_Map,
4941     IWineD3DSurfaceImpl_Unmap,
4942     IWineD3DSurfaceImpl_GetDC,
4943     IWineD3DSurfaceImpl_ReleaseDC,
4944     IWineD3DSurfaceImpl_Flip,
4945     IWineD3DSurfaceImpl_Blt,
4946     IWineD3DBaseSurfaceImpl_GetBltStatus,
4947     IWineD3DBaseSurfaceImpl_GetFlipStatus,
4948     IWineD3DBaseSurfaceImpl_IsLost,
4949     IWineD3DBaseSurfaceImpl_Restore,
4950     IWineD3DSurfaceImpl_BltFast,
4951     IWineD3DBaseSurfaceImpl_GetPalette,
4952     IWineD3DBaseSurfaceImpl_SetPalette,
4953     IWineD3DBaseSurfaceImpl_SetColorKey,
4954     IWineD3DBaseSurfaceImpl_GetPitch,
4955     IWineD3DSurfaceImpl_SetMem,
4956     IWineD3DBaseSurfaceImpl_SetOverlayPosition,
4957     IWineD3DBaseSurfaceImpl_GetOverlayPosition,
4958     IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder,
4959     IWineD3DBaseSurfaceImpl_UpdateOverlay,
4960     IWineD3DBaseSurfaceImpl_SetClipper,
4961     IWineD3DBaseSurfaceImpl_GetClipper,
4962     /* Internal use: */
4963     IWineD3DSurfaceImpl_SetFormat,
4964     IWineD3DSurfaceImpl_PrivateSetup,
4965     IWineD3DSurfaceImpl_GetImplType,
4966 };
4967
4968 static HRESULT ffp_blit_alloc(IWineD3DDeviceImpl *device) { return WINED3D_OK; }
4969 /* Context activation is done by the caller. */
4970 static void ffp_blit_free(IWineD3DDeviceImpl *device) { }
4971
4972 /* This function is used in case of 8bit paletted textures using GL_EXT_paletted_texture */
4973 /* Context activation is done by the caller. */
4974 static void ffp_blit_p8_upload_palette(IWineD3DSurfaceImpl *surface, const struct wined3d_gl_info *gl_info)
4975 {
4976     BYTE table[256][4];
4977     BOOL colorkey_active = (surface->CKeyFlags & WINEDDSD_CKSRCBLT) ? TRUE : FALSE;
4978
4979     d3dfmt_p8_init_palette(surface, table, colorkey_active);
4980
4981     TRACE("Using GL_EXT_PALETTED_TEXTURE for 8-bit paletted texture support\n");
4982     ENTER_GL();
4983     GL_EXTCALL(glColorTableEXT(surface->texture_target, GL_RGBA, 256, GL_RGBA, GL_UNSIGNED_BYTE, table));
4984     LEAVE_GL();
4985 }
4986
4987 /* Context activation is done by the caller. */
4988 static HRESULT ffp_blit_set(void *blit_priv, const struct wined3d_gl_info *gl_info, IWineD3DSurfaceImpl *surface)
4989 {
4990     enum complex_fixup fixup = get_complex_fixup(surface->resource.format->color_fixup);
4991
4992     /* When EXT_PALETTED_TEXTURE is around, palette conversion is done by the GPU
4993      * else the surface is converted in software at upload time in LoadLocation.
4994      */
4995     if(fixup == COMPLEX_FIXUP_P8 && gl_info->supported[EXT_PALETTED_TEXTURE])
4996         ffp_blit_p8_upload_palette(surface, gl_info);
4997
4998     ENTER_GL();
4999     glEnable(surface->texture_target);
5000     checkGLcall("glEnable(surface->texture_target)");
5001     LEAVE_GL();
5002     return WINED3D_OK;
5003 }
5004
5005 /* Context activation is done by the caller. */
5006 static void ffp_blit_unset(const struct wined3d_gl_info *gl_info)
5007 {
5008     ENTER_GL();
5009     glDisable(GL_TEXTURE_2D);
5010     checkGLcall("glDisable(GL_TEXTURE_2D)");
5011     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
5012     {
5013         glDisable(GL_TEXTURE_CUBE_MAP_ARB);
5014         checkGLcall("glDisable(GL_TEXTURE_CUBE_MAP_ARB)");
5015     }
5016     if (gl_info->supported[ARB_TEXTURE_RECTANGLE])
5017     {
5018         glDisable(GL_TEXTURE_RECTANGLE_ARB);
5019         checkGLcall("glDisable(GL_TEXTURE_RECTANGLE_ARB)");
5020     }
5021     LEAVE_GL();
5022 }
5023
5024 static BOOL ffp_blit_supported(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
5025         const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
5026         const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
5027 {
5028     enum complex_fixup src_fixup;
5029
5030     switch (blit_op)
5031     {
5032         case WINED3D_BLIT_OP_COLOR_BLIT:
5033             src_fixup = get_complex_fixup(src_format->color_fixup);
5034             if (TRACE_ON(d3d_surface) && TRACE_ON(d3d))
5035             {
5036                 TRACE("Checking support for fixup:\n");
5037                 dump_color_fixup_desc(src_format->color_fixup);
5038             }
5039
5040             if (!is_identity_fixup(dst_format->color_fixup))
5041             {
5042                 TRACE("Destination fixups are not supported\n");
5043                 return FALSE;
5044             }
5045
5046             if (src_fixup == COMPLEX_FIXUP_P8 && gl_info->supported[EXT_PALETTED_TEXTURE])
5047             {
5048                 TRACE("P8 fixup supported\n");
5049                 return TRUE;
5050             }
5051
5052             /* We only support identity conversions. */
5053             if (is_identity_fixup(src_format->color_fixup))
5054             {
5055                 TRACE("[OK]\n");
5056                 return TRUE;
5057             }
5058
5059             TRACE("[FAILED]\n");
5060             return FALSE;
5061
5062         case WINED3D_BLIT_OP_COLOR_FILL:
5063             if (!(dst_usage & WINED3DUSAGE_RENDERTARGET))
5064             {
5065                 TRACE("Color fill not supported\n");
5066                 return FALSE;
5067             }
5068
5069             return TRUE;
5070
5071         case WINED3D_BLIT_OP_DEPTH_FILL:
5072             return TRUE;
5073
5074         default:
5075             TRACE("Unsupported blit_op=%d\n", blit_op);
5076             return FALSE;
5077     }
5078 }
5079
5080 /* Do not call while under the GL lock. */
5081 static HRESULT ffp_blit_color_fill(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface,
5082         const RECT *dst_rect, const WINED3DCOLORVALUE *color)
5083 {
5084     const RECT draw_rect = {0, 0, dst_surface->resource.width, dst_surface->resource.height};
5085
5086     return device_clear_render_targets(device, 1, &dst_surface, NULL,
5087             1, dst_rect, &draw_rect, WINED3DCLEAR_TARGET, color, 0.0f, 0);
5088 }
5089
5090 /* Do not call while under the GL lock. */
5091 static HRESULT ffp_blit_depth_fill(IWineD3DDeviceImpl *device,
5092         IWineD3DSurfaceImpl *surface, const RECT *rect, float depth)
5093 {
5094     const RECT draw_rect = {0, 0, surface->resource.width, surface->resource.height};
5095
5096     return device_clear_render_targets(device, 0, NULL, surface,
5097             1, rect, &draw_rect, WINED3DCLEAR_ZBUFFER, 0, depth, 0);
5098 }
5099
5100 const struct blit_shader ffp_blit =  {
5101     ffp_blit_alloc,
5102     ffp_blit_free,
5103     ffp_blit_set,
5104     ffp_blit_unset,
5105     ffp_blit_supported,
5106     ffp_blit_color_fill,
5107     ffp_blit_depth_fill,
5108 };
5109
5110 static HRESULT cpu_blit_alloc(IWineD3DDeviceImpl *device)
5111 {
5112     return WINED3D_OK;
5113 }
5114
5115 /* Context activation is done by the caller. */
5116 static void cpu_blit_free(IWineD3DDeviceImpl *device)
5117 {
5118 }
5119
5120 /* Context activation is done by the caller. */
5121 static HRESULT cpu_blit_set(void *blit_priv, const struct wined3d_gl_info *gl_info, IWineD3DSurfaceImpl *surface)
5122 {
5123     return WINED3D_OK;
5124 }
5125
5126 /* Context activation is done by the caller. */
5127 static void cpu_blit_unset(const struct wined3d_gl_info *gl_info)
5128 {
5129 }
5130
5131 static BOOL cpu_blit_supported(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
5132         const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
5133         const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
5134 {
5135     if (blit_op == WINED3D_BLIT_OP_COLOR_FILL)
5136     {
5137         return TRUE;
5138     }
5139
5140     return FALSE;
5141 }
5142
5143 /* Do not call while under the GL lock. */
5144 static HRESULT cpu_blit_color_fill(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface,
5145         const RECT *dst_rect, const WINED3DCOLORVALUE *color)
5146 {
5147     WINEDDBLTFX BltFx;
5148
5149     memset(&BltFx, 0, sizeof(BltFx));
5150     BltFx.dwSize = sizeof(BltFx);
5151     BltFx.u5.dwFillColor = wined3d_format_convert_from_float(dst_surface->resource.format, color);
5152     return IWineD3DBaseSurfaceImpl_Blt((IWineD3DSurface*)dst_surface, dst_rect,
5153             NULL, NULL, WINEDDBLT_COLORFILL, &BltFx, WINED3DTEXF_POINT);
5154 }
5155
5156 /* Do not call while under the GL lock. */
5157 static HRESULT cpu_blit_depth_fill(IWineD3DDeviceImpl *device,
5158         IWineD3DSurfaceImpl *surface, const RECT *rect, float depth)
5159 {
5160     FIXME("Depth filling not implemented by cpu_blit.\n");
5161     return WINED3DERR_INVALIDCALL;
5162 }
5163
5164 const struct blit_shader cpu_blit =  {
5165     cpu_blit_alloc,
5166     cpu_blit_free,
5167     cpu_blit_set,
5168     cpu_blit_unset,
5169     cpu_blit_supported,
5170     cpu_blit_color_fill,
5171     cpu_blit_depth_fill,
5172 };
5173
5174 static BOOL fbo_blit_supported(const struct wined3d_gl_info *gl_info, enum wined3d_blit_op blit_op,
5175         const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
5176         const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
5177 {
5178     if ((wined3d_settings.offscreen_rendering_mode != ORM_FBO) || !gl_info->fbo_ops.glBlitFramebuffer)
5179         return FALSE;
5180
5181     /* Source and/or destination need to be on the GL side */
5182     if (src_pool == WINED3DPOOL_SYSTEMMEM || dst_pool == WINED3DPOOL_SYSTEMMEM)
5183         return FALSE;
5184
5185     switch (blit_op)
5186     {
5187         case WINED3D_BLIT_OP_COLOR_BLIT:
5188             if (!((src_format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (src_usage & WINED3DUSAGE_RENDERTARGET)))
5189                 return FALSE;
5190             if (!((dst_format->flags & WINED3DFMT_FLAG_FBO_ATTACHABLE) || (dst_usage & WINED3DUSAGE_RENDERTARGET)))
5191                 return FALSE;
5192             break;
5193
5194         case WINED3D_BLIT_OP_DEPTH_BLIT:
5195             if (!(src_format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
5196                 return FALSE;
5197             if (!(dst_format->flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
5198                 return FALSE;
5199             break;
5200
5201         default:
5202             return FALSE;
5203     }
5204
5205     if (!(src_format->id == dst_format->id
5206             || (is_identity_fixup(src_format->color_fixup)
5207             && is_identity_fixup(dst_format->color_fixup))))
5208         return FALSE;
5209
5210     return TRUE;
5211 }