dlls/wined3d/texture.c

   1 /*
   2  * Copyright 2002-2005 Jason Edmeades
   3  * Copyright 2002-2005 Raphael Junqueira
   4  * Copyright 2005 Oliver Stieber
   5  * Copyright 2007-2009, 2013 Stefan Dösinger for CodeWeavers
   6  * Copyright 2009-2011 Henri Verbeet for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25 #include "wined3d_private.h"
  26
  27 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  28 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  29 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  30
  31 #define WINED3D_TEXTURE_DYNAMIC_MAP_THRESHOLD 50
  32
  33 struct wined3d_texture_idx
  34 {
  35     struct wined3d_texture *texture;
  36     unsigned int sub_resource_idx;
  37 };
  38
  39 static BOOL wined3d_texture_use_pbo(const struct wined3d_texture *texture, const struct wined3d_gl_info *gl_info)
  40 {
  41     return !(texture->resource.access & WINED3D_RESOURCE_ACCESS_CPU)
  42             && texture->resource.usage & WINED3DUSAGE_DYNAMIC
  43             && gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]
  44             && !texture->resource.format->conv_byte_count
  45             && !(texture->flags & (WINED3D_TEXTURE_PIN_SYSMEM | WINED3D_TEXTURE_COND_NP2_EMULATED));
  46 }
  47
  48 static BOOL wined3d_texture_use_immutable_storage(const struct wined3d_texture *texture,
  49         const struct wined3d_gl_info *gl_info)
  50 {
  51     /* We don't expect to create texture views for textures with height-scaled formats.
  52      * Besides, ARB_texture_storage doesn't allow specifying exact sizes for all levels. */
  53     return gl_info->supported[ARB_TEXTURE_STORAGE]
  54             && !(texture->resource.format_flags & WINED3DFMT_FLAG_HEIGHT_SCALE);
  55 }
  56
  57 /* Front buffer coordinates are always full screen coordinates, but our GL
  58  * drawable is limited to the window's client area. The sysmem and texture
  59  * copies do have the full screen size. Note that GL has a bottom-left
  60  * origin, while D3D has a top-left origin. */
  61 void wined3d_texture_translate_drawable_coords(const struct wined3d_texture *texture, HWND window, RECT *rect)
  62 {
  63     unsigned int drawable_height;
  64     POINT offset = {0, 0};
  65     RECT windowsize;
  66
  67     if (!texture->swapchain)
  68         return;
  69
  70     if (texture == texture->swapchain->front_buffer)
  71     {
  72         ScreenToClient(window, &offset);
  73         OffsetRect(rect, offset.x, offset.y);
  74     }
  75
  76     GetClientRect(window, &windowsize);
  77     drawable_height = windowsize.bottom - windowsize.top;
  78
  79     rect->top = drawable_height - rect->top;
  80     rect->bottom = drawable_height - rect->bottom;
  81 }
  82
  83 GLenum wined3d_texture_get_gl_buffer(const struct wined3d_texture *texture)
  84 {
  85     const struct wined3d_swapchain *swapchain = texture->swapchain;
  86
  87     TRACE("texture %p.\n", texture);
  88
  89     if (!swapchain)
  90     {
  91         ERR("Texture %p is not part of a swapchain.\n", texture);
  92         return GL_NONE;
  93     }
  94
  95     if (texture == swapchain->front_buffer)
  96     {
  97         TRACE("Returning GL_FRONT.\n");
  98         return GL_FRONT;
  99     }
 100
 101     if (texture == swapchain->back_buffers[0])
 102     {
 103         TRACE("Returning GL_BACK.\n");
 104         return GL_BACK;
 105     }
 106
 107     FIXME("Higher back buffer, returning GL_BACK.\n");
 108     return GL_BACK;
 109 }
 110
 111 static DWORD wined3d_resource_access_from_location(DWORD location)
 112 {
 113     switch (location)
 114     {
 115         case WINED3D_LOCATION_DISCARDED:
 116             return 0;
 117
 118         case WINED3D_LOCATION_SYSMEM:
 119         case WINED3D_LOCATION_USER_MEMORY:
 120             return WINED3D_RESOURCE_ACCESS_CPU;
 121
 122         case WINED3D_LOCATION_BUFFER:
 123         case WINED3D_LOCATION_DRAWABLE:
 124         case WINED3D_LOCATION_TEXTURE_RGB:
 125         case WINED3D_LOCATION_TEXTURE_SRGB:
 126         case WINED3D_LOCATION_RB_MULTISAMPLE:
 127         case WINED3D_LOCATION_RB_RESOLVED:
 128             return WINED3D_RESOURCE_ACCESS_GPU;
 129
 130         default:
 131             FIXME("Unhandled location %#x.\n", location);
 132             return 0;
 133     }
 134 }
 135
 136 static void wined3d_texture_evict_sysmem(struct wined3d_texture *texture)
 137 {
 138     struct wined3d_texture_sub_resource *sub_resource;
 139     unsigned int i, sub_count;
 140
 141     if (texture->flags & (WINED3D_TEXTURE_CONVERTED | WINED3D_TEXTURE_PIN_SYSMEM)
 142             || texture->download_count > WINED3D_TEXTURE_DYNAMIC_MAP_THRESHOLD)
 143     {
 144         TRACE("Not evicting system memory for texture %p.\n", texture);
 145         return;
 146     }
 147
 148     TRACE("Evicting system memory for texture %p.\n", texture);
 149
 150     sub_count = texture->level_count * texture->layer_count;
 151     for (i = 0; i < sub_count; ++i)
 152     {
 153         sub_resource = &texture->sub_resources[i];
 154         if (sub_resource->locations == WINED3D_LOCATION_SYSMEM)
 155             ERR("WINED3D_LOCATION_SYSMEM is the only location for sub-resource %u of texture %p.\n",
 156                     i, texture);
 157         sub_resource->locations &= ~WINED3D_LOCATION_SYSMEM;
 158     }
 159     wined3d_resource_free_sysmem(&texture->resource);
 160 }
 161
 162 void wined3d_texture_validate_location(struct wined3d_texture *texture,
 163         unsigned int sub_resource_idx, DWORD location)
 164 {
 165     struct wined3d_texture_sub_resource *sub_resource;
 166     DWORD previous_locations;
 167
 168     TRACE("texture %p, sub_resource_idx %u, location %s.\n",
 169             texture, sub_resource_idx, wined3d_debug_location(location));
 170
 171     sub_resource = &texture->sub_resources[sub_resource_idx];
 172     previous_locations = sub_resource->locations;
 173     sub_resource->locations |= location;
 174     if (previous_locations == WINED3D_LOCATION_SYSMEM && location != WINED3D_LOCATION_SYSMEM
 175             && !--texture->sysmem_count)
 176         wined3d_texture_evict_sysmem(texture);
 177
 178     TRACE("New locations flags are %s.\n", wined3d_debug_location(sub_resource->locations));
 179 }
 180
 181 static void wined3d_texture_set_dirty(struct wined3d_texture *texture)
 182 {
 183     texture->flags &= ~(WINED3D_TEXTURE_RGB_VALID | WINED3D_TEXTURE_SRGB_VALID);
 184 }
 185
 186 void wined3d_texture_invalidate_location(struct wined3d_texture *texture,
 187         unsigned int sub_resource_idx, DWORD location)
 188 {
 189     struct wined3d_texture_sub_resource *sub_resource;
 190     DWORD previous_locations;
 191
 192     TRACE("texture %p, sub_resource_idx %u, location %s.\n",
 193             texture, sub_resource_idx, wined3d_debug_location(location));
 194
 195     if (location & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
 196         wined3d_texture_set_dirty(texture);
 197
 198     sub_resource = &texture->sub_resources[sub_resource_idx];
 199     previous_locations = sub_resource->locations;
 200     sub_resource->locations &= ~location;
 201     if (previous_locations != WINED3D_LOCATION_SYSMEM && sub_resource->locations == WINED3D_LOCATION_SYSMEM)
 202         ++texture->sysmem_count;
 203
 204     TRACE("New locations flags are %s.\n", wined3d_debug_location(sub_resource->locations));
 205
 206     if (!sub_resource->locations)
 207         ERR("Sub-resource %u of texture %p does not have any up to date location.\n",
 208                 sub_resource_idx, texture);
 209 }
 210
 211 static BOOL wined3d_texture_copy_sysmem_location(struct wined3d_texture *texture,
 212         unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
 213 {
 214     unsigned int size = texture->sub_resources[sub_resource_idx].size;
 215     struct wined3d_device *device = texture->resource.device;
 216     const struct wined3d_gl_info *gl_info;
 217     struct wined3d_bo_address dst, src;
 218
 219     if (!wined3d_texture_prepare_location(texture, sub_resource_idx, context, location))
 220         return FALSE;
 221
 222     wined3d_texture_get_memory(texture, sub_resource_idx, &dst, location);
 223     wined3d_texture_get_memory(texture, sub_resource_idx, &src,
 224             texture->sub_resources[sub_resource_idx].locations);
 225
 226     if (dst.buffer_object)
 227     {
 228         context = context_acquire(device, NULL, 0);
 229         gl_info = context->gl_info;
 230         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, dst.buffer_object));
 231         GL_EXTCALL(glBufferSubData(GL_PIXEL_UNPACK_BUFFER, 0, size, src.addr));
 232         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
 233         checkGLcall("PBO upload");
 234         context_release(context);
 235         return TRUE;
 236     }
 237
 238     if (src.buffer_object)
 239     {
 240         context = context_acquire(device, NULL, 0);
 241         gl_info = context->gl_info;
 242         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, src.buffer_object));
 243         GL_EXTCALL(glGetBufferSubData(GL_PIXEL_PACK_BUFFER, 0, size, dst.addr));
 244         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
 245         checkGLcall("PBO download");
 246         context_release(context);
 247         return TRUE;
 248     }
 249
 250     memcpy(dst.addr, src.addr, size);
 251     return TRUE;
 252 }
 253
 254 /* Context activation is done by the caller. Context may be NULL in
 255  * WINED3D_NO3D mode. */
 256 BOOL wined3d_texture_load_location(struct wined3d_texture *texture,
 257         unsigned int sub_resource_idx, struct wined3d_context *context, DWORD location)
 258 {
 259     static const DWORD sysmem_locations = WINED3D_LOCATION_SYSMEM | WINED3D_LOCATION_USER_MEMORY
 260             | WINED3D_LOCATION_BUFFER;
 261     DWORD current = texture->sub_resources[sub_resource_idx].locations;
 262     BOOL ret;
 263
 264     TRACE("texture %p, sub_resource_idx %u, context %p, location %s.\n",
 265             texture, sub_resource_idx, context, wined3d_debug_location(location));
 266
 267     TRACE("Current resource location %s.\n", wined3d_debug_location(current));
 268
 269     if (current & location)
 270     {
 271         TRACE("Location %s is already up to date.\n", wined3d_debug_location(location));
 272         return TRUE;
 273     }
 274
 275     if (WARN_ON(d3d))
 276     {
 277         DWORD required_access = wined3d_resource_access_from_location(location);
 278         if ((texture->resource.access & required_access) != required_access)
 279             WARN("Operation requires %#x access, but texture only has %#x.\n",
 280                     required_access, texture->resource.access);
 281     }
 282
 283     if (current & WINED3D_LOCATION_DISCARDED)
 284     {
 285         TRACE("Sub-resource previously discarded, nothing to do.\n");
 286         if (!wined3d_texture_prepare_location(texture, sub_resource_idx, context, location))
 287             return FALSE;
 288         wined3d_texture_validate_location(texture, sub_resource_idx, location);
 289         wined3d_texture_invalidate_location(texture, sub_resource_idx, WINED3D_LOCATION_DISCARDED);
 290         return TRUE;
 291     }
 292
 293     if (!current)
 294     {
 295         ERR("Sub-resource %u of texture %p does not have any up to date location.\n",
 296                 sub_resource_idx, texture);
 297         wined3d_texture_validate_location(texture, sub_resource_idx, WINED3D_LOCATION_DISCARDED);
 298         return wined3d_texture_load_location(texture, sub_resource_idx, context, location);
 299     }
 300
 301     if ((location & sysmem_locations) && (current & sysmem_locations))
 302         ret = wined3d_texture_copy_sysmem_location(texture, sub_resource_idx, context, location);
 303     else
 304         ret = texture->texture_ops->texture_load_location(texture, sub_resource_idx, context, location);
 305
 306     if (ret)
 307         wined3d_texture_validate_location(texture, sub_resource_idx, location);
 308
 309     return ret;
 310 }
 311
 312 void wined3d_texture_get_memory(struct wined3d_texture *texture, unsigned int sub_resource_idx,
 313         struct wined3d_bo_address *data, DWORD locations)
 314 {
 315     struct wined3d_texture_sub_resource *sub_resource;
 316
 317     TRACE("texture %p, sub_resource_idx %u, data %p, locations %s.\n",
 318             texture, sub_resource_idx, data, wined3d_debug_location(locations));
 319
 320     sub_resource = &texture->sub_resources[sub_resource_idx];
 321     if (locations & WINED3D_LOCATION_BUFFER)
 322     {
 323         data->addr = NULL;
 324         data->buffer_object = sub_resource->buffer_object;
 325         return;
 326     }
 327     if (locations & WINED3D_LOCATION_USER_MEMORY)
 328     {
 329         data->addr = texture->user_memory;
 330         data->buffer_object = 0;
 331         return;
 332     }
 333     if (locations & WINED3D_LOCATION_SYSMEM)
 334     {
 335         data->addr = texture->resource.heap_memory;
 336         data->addr += sub_resource->offset;
 337         data->buffer_object = 0;
 338         return;
 339     }
 340
 341     ERR("Unexpected locations %s.\n", wined3d_debug_location(locations));
 342     data->addr = NULL;
 343     data->buffer_object = 0;
 344 }
 345
 346 /* Context activation is done by the caller. */
 347 static void wined3d_texture_remove_buffer_object(struct wined3d_texture *texture,
 348         unsigned int sub_resource_idx, const struct wined3d_gl_info *gl_info)
 349 {
 350     GLuint *buffer_object = &texture->sub_resources[sub_resource_idx].buffer_object;
 351
 352     GL_EXTCALL(glDeleteBuffers(1, buffer_object));
 353     checkGLcall("glDeleteBuffers");
 354
 355     TRACE("Deleted buffer object %u for texture %p, sub-resource %u.\n",
 356             *buffer_object, texture, sub_resource_idx);
 357
 358     wined3d_texture_invalidate_location(texture, sub_resource_idx, WINED3D_LOCATION_BUFFER);
 359     *buffer_object = 0;
 360 }
 361
 362 static void wined3d_texture_update_map_binding(struct wined3d_texture *texture)
 363 {
 364     unsigned int sub_count = texture->level_count * texture->layer_count;
 365     const struct wined3d_device *device = texture->resource.device;
 366     DWORD map_binding = texture->update_map_binding;
 367     struct wined3d_context *context = NULL;
 368     unsigned int i;
 369
 370     if (device->d3d_initialized)
 371         context = context_acquire(device, NULL, 0);
 372
 373     for (i = 0; i < sub_count; ++i)
 374     {
 375         if (texture->sub_resources[i].locations == texture->resource.map_binding
 376                 && !wined3d_texture_load_location(texture, i, context, map_binding))
 377             ERR("Failed to load location %s.\n", wined3d_debug_location(map_binding));
 378         if (texture->resource.map_binding == WINED3D_LOCATION_BUFFER)
 379             wined3d_texture_remove_buffer_object(texture, i, context->gl_info);
 380     }
 381
 382     if (context)
 383         context_release(context);
 384
 385     texture->resource.map_binding = map_binding;
 386     texture->update_map_binding = 0;
 387 }
 388
 389 void wined3d_texture_set_map_binding(struct wined3d_texture *texture, DWORD map_binding)
 390 {
 391     texture->update_map_binding = map_binding;
 392     if (!texture->resource.map_count)
 393         wined3d_texture_update_map_binding(texture);
 394 }
 395
 396 /* A GL context is provided by the caller */
 397 static void gltexture_delete(struct wined3d_device *device, const struct wined3d_gl_info *gl_info,
 398         struct gl_texture *tex)
 399 {
 400     context_gl_resource_released(device, tex->name, FALSE);
 401     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex->name);
 402     tex->name = 0;
 403 }
 404
 405 static unsigned int wined3d_texture_get_gl_sample_count(const struct wined3d_texture *texture)
 406 {
 407     const struct wined3d_format *format = texture->resource.format;
 408
 409     /* TODO: NVIDIA expose their Coverage Sample Anti-Aliasing (CSAA)
 410      * feature through type == MULTISAMPLE_XX and quality != 0. This could
 411      * be mapped to GL_NV_framebuffer_multisample_coverage.
 412      *
 413      * AMD have a similar feature called Enhanced Quality Anti-Aliasing
 414      * (EQAA), but it does not have an equivalent OpenGL extension. */
 415
 416     /* We advertise as many WINED3D_MULTISAMPLE_NON_MASKABLE quality
 417      * levels as the count of advertised multisample types for the texture
 418      * format. */
 419     if (texture->resource.multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE)
 420     {
 421         unsigned int i, count = 0;
 422
 423         for (i = 0; i < sizeof(format->multisample_types) * CHAR_BIT; ++i)
 424         {
 425             if (format->multisample_types & 1u << i)
 426             {
 427                 if (texture->resource.multisample_quality == count++)
 428                     break;
 429             }
 430         }
 431         return i + 1;
 432     }
 433
 434     return texture->resource.multisample_type;
 435 }
 436
 437 /* Context activation is done by the caller. */
 438 /* The caller is responsible for binding the correct texture. */
 439 static void wined3d_texture_allocate_gl_mutable_storage(struct wined3d_texture *texture,
 440         GLenum gl_internal_format, const struct wined3d_format *format,
 441         const struct wined3d_gl_info *gl_info)
 442 {
 443     unsigned int level, level_count, layer, layer_count;
 444     GLsizei width, height, depth;
 445     GLenum target;
 446
 447     level_count = texture->level_count;
 448     layer_count = texture->target == GL_TEXTURE_2D_ARRAY ? 1 : texture->layer_count;
 449
 450     for (layer = 0; layer < layer_count; ++layer)
 451     {
 452         target = wined3d_texture_get_sub_resource_target(texture, layer * level_count);
 453
 454         for (level = 0; level < level_count; ++level)
 455         {
 456             width = wined3d_texture_get_level_pow2_width(texture, level);
 457             height = wined3d_texture_get_level_pow2_height(texture, level);
 458             if (texture->resource.format_flags & WINED3DFMT_FLAG_HEIGHT_SCALE)
 459             {
 460                 height *= format->height_scale.numerator;
 461                 height /= format->height_scale.denominator;
 462             }
 463
 464             TRACE("texture %p, layer %u, level %u, target %#x, width %u, height %u.\n",
 465                     texture, layer, level, target, width, height);
 466
 467             if (target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY)
 468             {
 469                 depth = wined3d_texture_get_level_depth(texture, level);
 470                 GL_EXTCALL(glTexImage3D(target, level, gl_internal_format, width, height,
 471                         target == GL_TEXTURE_2D_ARRAY ? texture->layer_count : depth, 0,
 472                         format->glFormat, format->glType, NULL));
 473                 checkGLcall("glTexImage3D");
 474             }
 475             else
 476             {
 477                 gl_info->gl_ops.gl.p_glTexImage2D(target, level, gl_internal_format,
 478                         width, height, 0, format->glFormat, format->glType, NULL);
 479                 checkGLcall("glTexImage2D");
 480             }
 481         }
 482     }
 483 }
 484
 485 /* Context activation is done by the caller. */
 486 /* The caller is responsible for binding the correct texture. */
 487 static void wined3d_texture_allocate_gl_immutable_storage(struct wined3d_texture *texture,
 488         GLenum gl_internal_format, const struct wined3d_gl_info *gl_info)
 489 {
 490     unsigned int samples = wined3d_texture_get_gl_sample_count(texture);
 491     GLsizei height = wined3d_texture_get_level_pow2_height(texture, 0);
 492     GLsizei width = wined3d_texture_get_level_pow2_width(texture, 0);
 493
 494     switch (texture->target)
 495     {
 496         case GL_TEXTURE_3D:
 497             GL_EXTCALL(glTexStorage3D(texture->target, texture->level_count,
 498                     gl_internal_format, width, height, wined3d_texture_get_level_depth(texture, 0)));
 499             break;
 500         case GL_TEXTURE_2D_ARRAY:
 501             GL_EXTCALL(glTexStorage3D(texture->target, texture->level_count,
 502                     gl_internal_format, width, height, texture->layer_count));
 503             break;
 504         case GL_TEXTURE_2D_MULTISAMPLE:
 505             GL_EXTCALL(glTexStorage2DMultisample(texture->target, samples,
 506                     gl_internal_format, width, height, GL_FALSE));
 507             break;
 508         case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
 509             GL_EXTCALL(glTexStorage3DMultisample(texture->target, samples,
 510                     gl_internal_format, width, height, texture->layer_count, GL_FALSE));
 511             break;
 512         default:
 513             GL_EXTCALL(glTexStorage2D(texture->target, texture->level_count,
 514                     gl_internal_format, width, height));
 515             break;
 516     }
 517
 518     checkGLcall("allocate immutable storage");
 519 }
 520
 521 static void wined3d_texture_unload_gl_texture(struct wined3d_texture *texture)
 522 {
 523     struct wined3d_device *device = texture->resource.device;
 524     const struct wined3d_gl_info *gl_info = NULL;
 525     struct wined3d_context *context = NULL;
 526
 527     if (texture->texture_rgb.name || texture->texture_srgb.name
 528             || texture->rb_multisample || texture->rb_resolved)
 529     {
 530         context = context_acquire(device, NULL, 0);
 531         gl_info = context->gl_info;
 532     }
 533
 534     if (texture->texture_rgb.name)
 535         gltexture_delete(device, context->gl_info, &texture->texture_rgb);
 536
 537     if (texture->texture_srgb.name)
 538         gltexture_delete(device, context->gl_info, &texture->texture_srgb);
 539
 540     if (texture->rb_multisample)
 541     {
 542         TRACE("Deleting multisample renderbuffer %u.\n", texture->rb_multisample);
 543         context_gl_resource_released(device, texture->rb_multisample, TRUE);
 544         gl_info->fbo_ops.glDeleteRenderbuffers(1, &texture->rb_multisample);
 545         texture->rb_multisample = 0;
 546     }
 547
 548     if (texture->rb_resolved)
 549     {
 550         TRACE("Deleting resolved renderbuffer %u.\n", texture->rb_resolved);
 551         context_gl_resource_released(device, texture->rb_resolved, TRUE);
 552         gl_info->fbo_ops.glDeleteRenderbuffers(1, &texture->rb_resolved);
 553         texture->rb_resolved = 0;
 554     }
 555
 556     if (context) context_release(context);
 557
 558     wined3d_texture_set_dirty(texture);
 559
 560     resource_unload(&texture->resource);
 561 }
 562
 563 static void wined3d_texture_sub_resources_destroyed(struct wined3d_texture *texture)
 564 {
 565     unsigned int sub_count = texture->level_count * texture->layer_count;
 566     struct wined3d_texture_sub_resource *sub_resource;
 567     unsigned int i;
 568
 569     for (i = 0; i < sub_count; ++i)
 570     {
 571         sub_resource = &texture->sub_resources[i];
 572         if (sub_resource->parent)
 573         {
 574             TRACE("sub-resource %u.\n", i);
 575             sub_resource->parent_ops->wined3d_object_destroyed(sub_resource->parent);
 576             sub_resource->parent = NULL;
 577         }
 578     }
 579 }
 580
 581 static void wined3d_texture_create_dc(void *object)
 582 {
 583     const struct wined3d_texture_idx *idx = object;
 584     struct wined3d_context *context = NULL;
 585     unsigned int sub_resource_idx, level;
 586     const struct wined3d_format *format;
 587     unsigned int row_pitch, slice_pitch;
 588     struct wined3d_texture *texture;
 589     struct wined3d_dc_info *dc_info;
 590     struct wined3d_bo_address data;
 591     D3DKMT_CREATEDCFROMMEMORY desc;
 592     struct wined3d_device *device;
 593     NTSTATUS status;
 594
 595     TRACE("texture %p, sub_resource_idx %u.\n", idx->texture, idx->sub_resource_idx);
 596
 597     texture = idx->texture;
 598     sub_resource_idx = idx->sub_resource_idx;
 599     level = sub_resource_idx % texture->level_count;
 600     device = texture->resource.device;
 601
 602     format = texture->resource.format;
 603     if (!format->ddi_format)
 604     {
 605         WARN("Cannot create a DC for format %s.\n", debug_d3dformat(format->id));
 606         return;
 607     }
 608
 609     if (!texture->dc_info)
 610     {
 611         unsigned int sub_count = texture->level_count * texture->layer_count;
 612
 613         if (!(texture->dc_info = heap_calloc(sub_count, sizeof(*texture->dc_info))))
 614         {
 615             ERR("Failed to allocate DC info.\n");
 616             return;
 617         }
 618     }
 619
 620     if (device->d3d_initialized)
 621         context = context_acquire(device, NULL, 0);
 622
 623     wined3d_texture_load_location(texture, sub_resource_idx, context, texture->resource.map_binding);
 624     wined3d_texture_invalidate_location(texture, sub_resource_idx, ~texture->resource.map_binding);
 625     wined3d_texture_get_pitch(texture, level, &row_pitch, &slice_pitch);
 626     wined3d_texture_get_memory(texture, sub_resource_idx, &data, texture->resource.map_binding);
 627     desc.pMemory = context_map_bo_address(context, &data,
 628             texture->sub_resources[sub_resource_idx].size,
 629             GL_PIXEL_UNPACK_BUFFER, WINED3D_MAP_READ | WINED3D_MAP_WRITE);
 630
 631     if (context)
 632         context_release(context);
 633
 634     desc.Format = format->ddi_format;
 635     desc.Width = wined3d_texture_get_level_width(texture, level);
 636     desc.Height = wined3d_texture_get_level_height(texture, level);
 637     desc.Pitch = row_pitch;
 638     desc.hDeviceDc = CreateCompatibleDC(NULL);
 639     desc.pColorTable = NULL;
 640
 641     status = D3DKMTCreateDCFromMemory(&desc);
 642     DeleteDC(desc.hDeviceDc);
 643     if (status)
 644     {
 645         WARN("Failed to create DC, status %#x.\n", status);
 646         return;
 647     }
 648
 649     dc_info = &texture->dc_info[sub_resource_idx];
 650     dc_info->dc = desc.hDc;
 651     dc_info->bitmap = desc.hBitmap;
 652
 653     TRACE("Created DC %p, bitmap %p for texture %p, %u.\n", dc_info->dc, dc_info->bitmap, texture, sub_resource_idx);
 654 }
 655
 656 static void wined3d_texture_destroy_dc(void *object)
 657 {
 658     const struct wined3d_texture_idx *idx = object;
 659     D3DKMT_DESTROYDCFROMMEMORY destroy_desc;
 660     struct wined3d_context *context = NULL;
 661     struct wined3d_texture *texture;
 662     struct wined3d_dc_info *dc_info;
 663     struct wined3d_bo_address data;
 664     unsigned int sub_resource_idx;
 665     struct wined3d_device *device;
 666     NTSTATUS status;
 667
 668     texture = idx->texture;
 669     sub_resource_idx = idx->sub_resource_idx;
 670     device = texture->resource.device;
 671     dc_info = &texture->dc_info[sub_resource_idx];
 672
 673     if (!dc_info->dc)
 674     {
 675         ERR("Sub-resource {%p, %u} has no DC.\n", texture, sub_resource_idx);
 676         return;
 677     }
 678
 679     TRACE("dc %p, bitmap %p.\n", dc_info->dc, dc_info->bitmap);
 680
 681     destroy_desc.hDc = dc_info->dc;
 682     destroy_desc.hBitmap = dc_info->bitmap;
 683     if ((status = D3DKMTDestroyDCFromMemory(&destroy_desc)))
 684         ERR("Failed to destroy dc, status %#x.\n", status);
 685     dc_info->dc = NULL;
 686     dc_info->bitmap = NULL;
 687
 688     if (device->d3d_initialized)
 689         context = context_acquire(device, NULL, 0);
 690
 691     wined3d_texture_get_memory(texture, sub_resource_idx, &data, texture->resource.map_binding);
 692     context_unmap_bo_address(context, &data, GL_PIXEL_UNPACK_BUFFER);
 693
 694     if (context)
 695         context_release(context);
 696 }
 697
 698 static void wined3d_texture_cleanup(struct wined3d_texture *texture)
 699 {
 700     unsigned int sub_count = texture->level_count * texture->layer_count;
 701     struct wined3d_device *device = texture->resource.device;
 702     struct wined3d_renderbuffer_entry *entry, *entry2;
 703     const struct wined3d_gl_info *gl_info = NULL;
 704     struct wined3d_context *context = NULL;
 705     struct wined3d_dc_info *dc_info;
 706     GLuint buffer_object;
 707     unsigned int i;
 708
 709     TRACE("texture %p.\n", texture);
 710
 711     for (i = 0; i < sub_count; ++i)
 712     {
 713         if (!(buffer_object = texture->sub_resources[i].buffer_object))
 714             continue;
 715
 716         TRACE("Deleting buffer object %u.\n", buffer_object);
 717
 718         /* We may not be able to get a context in wined3d_texture_cleanup() in
 719          * general, but if a buffer object was previously created we can. */
 720         if (!context)
 721         {
 722             context = context_acquire(device, NULL, 0);
 723             gl_info = context->gl_info;
 724         }
 725
 726         GL_EXTCALL(glDeleteBuffers(1, &buffer_object));
 727     }
 728
 729     if (!context && !list_empty(&texture->renderbuffers))
 730     {
 731         context = context_acquire(device, NULL, 0);
 732         gl_info = context->gl_info;
 733     }
 734
 735     LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &texture->renderbuffers, struct wined3d_renderbuffer_entry, entry)
 736     {
 737         TRACE("Deleting renderbuffer %u.\n", entry->id);
 738         context_gl_resource_released(device, entry->id, TRUE);
 739         gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
 740         heap_free(entry);
 741     }
 742
 743     if (context)
 744         context_release(context);
 745
 746     if ((dc_info = texture->dc_info))
 747     {
 748         for (i = 0; i < sub_count; ++i)
 749         {
 750             if (dc_info[i].dc)
 751             {
 752                 struct wined3d_texture_idx texture_idx = {texture, i};
 753
 754                 wined3d_texture_destroy_dc(&texture_idx);
 755             }
 756         }
 757         heap_free(dc_info);
 758     }
 759
 760     if (texture->overlay_info)
 761     {
 762         for (i = 0; i < sub_count; ++i)
 763         {
 764             struct wined3d_overlay_info *info = &texture->overlay_info[i];
 765             struct wined3d_overlay_info *overlay, *cur;
 766
 767             list_remove(&info->entry);
 768             LIST_FOR_EACH_ENTRY_SAFE(overlay, cur, &info->overlays, struct wined3d_overlay_info, entry)
 769             {
 770                 list_remove(&overlay->entry);
 771             }
 772         }
 773         heap_free(texture->overlay_info);
 774     }
 775     wined3d_texture_unload_gl_texture(texture);
 776 }
 777
 778 void wined3d_texture_set_swapchain(struct wined3d_texture *texture, struct wined3d_swapchain *swapchain)
 779 {
 780     texture->swapchain = swapchain;
 781     wined3d_resource_update_draw_binding(&texture->resource);
 782 }
 783
 784 /* Context activation is done by the caller. */
 785 void wined3d_texture_bind(struct wined3d_texture *texture,
 786         struct wined3d_context *context, BOOL srgb)
 787 {
 788     const struct wined3d_gl_info *gl_info = context->gl_info;
 789     const struct wined3d_format *format = texture->resource.format;
 790     const struct color_fixup_desc fixup = format->color_fixup;
 791     struct gl_texture *gl_tex;
 792     GLenum target;
 793
 794     TRACE("texture %p, context %p, srgb %#x.\n", texture, context, srgb);
 795
 796     if (!needs_separate_srgb_gl_texture(context, texture))
 797         srgb = FALSE;
 798
 799     /* sRGB mode cache for preload() calls outside drawprim. */
 800     if (srgb)
 801         texture->flags |= WINED3D_TEXTURE_IS_SRGB;
 802     else
 803         texture->flags &= ~WINED3D_TEXTURE_IS_SRGB;
 804
 805     gl_tex = wined3d_texture_get_gl_texture(texture, srgb);
 806     target = texture->target;
 807
 808     if (gl_tex->name)
 809     {
 810         context_bind_texture(context, target, gl_tex->name);
 811         return;
 812     }
 813
 814     gl_info->gl_ops.gl.p_glGenTextures(1, &gl_tex->name);
 815     checkGLcall("glGenTextures");
 816     TRACE("Generated texture %d.\n", gl_tex->name);
 817
 818     if (!gl_tex->name)
 819     {
 820         ERR("Failed to generate a texture name.\n");
 821         return;
 822     }
 823
 824     /* Initialise the state of the texture object to the OpenGL defaults, not
 825      * the wined3d defaults. */
 826     gl_tex->sampler_desc.address_u = WINED3D_TADDRESS_WRAP;
 827     gl_tex->sampler_desc.address_v = WINED3D_TADDRESS_WRAP;
 828     gl_tex->sampler_desc.address_w = WINED3D_TADDRESS_WRAP;
 829     memset(gl_tex->sampler_desc.border_color, 0, sizeof(gl_tex->sampler_desc.border_color));
 830     gl_tex->sampler_desc.mag_filter = WINED3D_TEXF_LINEAR;
 831     gl_tex->sampler_desc.min_filter = WINED3D_TEXF_POINT; /* GL_NEAREST_MIPMAP_LINEAR */
 832     gl_tex->sampler_desc.mip_filter = WINED3D_TEXF_LINEAR; /* GL_NEAREST_MIPMAP_LINEAR */
 833     gl_tex->sampler_desc.lod_bias = 0.0f;
 834     gl_tex->sampler_desc.min_lod = -1000.0f;
 835     gl_tex->sampler_desc.max_lod = 1000.0f;
 836     gl_tex->sampler_desc.max_anisotropy = 1;
 837     gl_tex->sampler_desc.compare = FALSE;
 838     gl_tex->sampler_desc.comparison_func = WINED3D_CMP_LESSEQUAL;
 839     if (context->gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
 840         gl_tex->sampler_desc.srgb_decode = TRUE;
 841     else
 842         gl_tex->sampler_desc.srgb_decode = srgb;
 843     gl_tex->base_level = 0;
 844     wined3d_texture_set_dirty(texture);
 845
 846     context_bind_texture(context, target, gl_tex->name);
 847
 848     /* For a new texture we have to set the texture levels after binding the
 849      * texture. Beware that texture rectangles do not support mipmapping, but
 850      * set the maxmiplevel if we're relying on the partial
 851      * GL_ARB_texture_non_power_of_two emulation with texture rectangles.
 852      * (I.e., do not care about cond_np2 here, just look for
 853      * GL_TEXTURE_RECTANGLE_ARB.) */
 854     if (target != GL_TEXTURE_RECTANGLE_ARB)
 855     {
 856         TRACE("Setting GL_TEXTURE_MAX_LEVEL to %u.\n", texture->level_count - 1);
 857         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, texture->level_count - 1);
 858         checkGLcall("glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, texture->level_count)");
 859     }
 860
 861     if (target == GL_TEXTURE_CUBE_MAP_ARB)
 862     {
 863         /* Cubemaps are always set to clamp, regardless of the sampler state. */
 864         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 865         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 866         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
 867     }
 868
 869     if (texture->flags & WINED3D_TEXTURE_COND_NP2)
 870     {
 871         /* Conditinal non power of two textures use a different clamping
 872          * default. If we're using the GL_WINE_normalized_texrect partial
 873          * driver emulation, we're dealing with a GL_TEXTURE_2D texture which
 874          * has the address mode set to repeat - something that prevents us
 875          * from hitting the accelerated codepath. Thus manually set the GL
 876          * state. The same applies to filtering. Even if the texture has only
 877          * one mip level, the default LINEAR_MIPMAP_LINEAR filter causes a SW
 878          * fallback on macos. */
 879         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 880         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 881         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 882         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 883         checkGLcall("glTexParameteri");
 884         gl_tex->sampler_desc.address_u = WINED3D_TADDRESS_CLAMP;
 885         gl_tex->sampler_desc.address_v = WINED3D_TADDRESS_CLAMP;
 886         gl_tex->sampler_desc.mag_filter = WINED3D_TEXF_POINT;
 887         gl_tex->sampler_desc.min_filter = WINED3D_TEXF_POINT;
 888         gl_tex->sampler_desc.mip_filter = WINED3D_TEXF_NONE;
 889     }
 890
 891     if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] && gl_info->supported[ARB_DEPTH_TEXTURE])
 892     {
 893         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY);
 894         checkGLcall("glTexParameteri(GL_DEPTH_TEXTURE_MODE_ARB, GL_INTENSITY)");
 895     }
 896
 897     if (!is_identity_fixup(fixup) && can_use_texture_swizzle(gl_info, format))
 898     {
 899         static const GLenum swizzle_source[] =
 900         {
 901             GL_ZERO,  /* CHANNEL_SOURCE_ZERO */
 902             GL_ONE,   /* CHANNEL_SOURCE_ONE */
 903             GL_RED,   /* CHANNEL_SOURCE_X */
 904             GL_GREEN, /* CHANNEL_SOURCE_Y */
 905             GL_BLUE,  /* CHANNEL_SOURCE_Z */
 906             GL_ALPHA, /* CHANNEL_SOURCE_W */
 907         };
 908         struct
 909         {
 910             GLint x, y, z, w;
 911         }
 912         swizzle;
 913
 914         swizzle.x = swizzle_source[fixup.x_source];
 915         swizzle.y = swizzle_source[fixup.y_source];
 916         swizzle.z = swizzle_source[fixup.z_source];
 917         swizzle.w = swizzle_source[fixup.w_source];
 918         gl_info->gl_ops.gl.p_glTexParameteriv(target, GL_TEXTURE_SWIZZLE_RGBA, &swizzle.x);
 919         checkGLcall("glTexParameteriv(GL_TEXTURE_SWIZZLE_RGBA)");
 920     }
 921 }
 922
 923 /* Context activation is done by the caller. */
 924 void wined3d_texture_bind_and_dirtify(struct wined3d_texture *texture,
 925         struct wined3d_context *context, BOOL srgb)
 926 {
 927     /* We don't need a specific texture unit, but after binding the texture
 928      * the current unit is dirty. Read the unit back instead of switching to
 929      * 0, this avoids messing around with the state manager's GL states. The
 930      * current texture unit should always be a valid one.
 931      *
 932      * To be more specific, this is tricky because we can implicitly be
 933      * called from sampler() in state.c. This means we can't touch anything
 934      * other than whatever happens to be the currently active texture, or we
 935      * would risk marking already applied sampler states dirty again. */
 936     if (context->active_texture < ARRAY_SIZE(context->rev_tex_unit_map))
 937     {
 938         DWORD active_sampler = context->rev_tex_unit_map[context->active_texture];
 939         if (active_sampler != WINED3D_UNMAPPED_STAGE)
 940             context_invalidate_state(context, STATE_SAMPLER(active_sampler));
 941     }
 942     /* FIXME: Ideally we'd only do this when touching a binding that's used by
 943      * a shader. */
 944     context_invalidate_compute_state(context, STATE_COMPUTE_SHADER_RESOURCE_BINDING);
 945     context_invalidate_state(context, STATE_GRAPHICS_SHADER_RESOURCE_BINDING);
 946
 947     wined3d_texture_bind(texture, context, srgb);
 948 }
 949
 950 /* Context activation is done by the caller (state handler). */
 951 /* This function relies on the correct texture being bound and loaded. */
 952 void wined3d_texture_apply_sampler_desc(struct wined3d_texture *texture,
 953         const struct wined3d_sampler_desc *sampler_desc, const struct wined3d_context *context)
 954 {
 955     const struct wined3d_gl_info *gl_info = context->gl_info;
 956     GLenum target = texture->target;
 957     struct gl_texture *gl_tex;
 958     DWORD state;
 959
 960     TRACE("texture %p, sampler_desc %p, context %p.\n", texture, sampler_desc, context);
 961
 962     gl_tex = wined3d_texture_get_gl_texture(texture, texture->flags & WINED3D_TEXTURE_IS_SRGB);
 963
 964     state = sampler_desc->address_u;
 965     if (state != gl_tex->sampler_desc.address_u)
 966     {
 967         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_S,
 968                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 969         gl_tex->sampler_desc.address_u = state;
 970     }
 971
 972     state = sampler_desc->address_v;
 973     if (state != gl_tex->sampler_desc.address_v)
 974     {
 975         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_T,
 976                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 977         gl_tex->sampler_desc.address_v = state;
 978     }
 979
 980     state = sampler_desc->address_w;
 981     if (state != gl_tex->sampler_desc.address_w)
 982     {
 983         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_WRAP_R,
 984                 gl_info->wrap_lookup[state - WINED3D_TADDRESS_WRAP]);
 985         gl_tex->sampler_desc.address_w = state;
 986     }
 987
 988     if (memcmp(gl_tex->sampler_desc.border_color, sampler_desc->border_color,
 989             sizeof(gl_tex->sampler_desc.border_color)))
 990     {
 991         gl_info->gl_ops.gl.p_glTexParameterfv(target, GL_TEXTURE_BORDER_COLOR, &sampler_desc->border_color[0]);
 992         memcpy(gl_tex->sampler_desc.border_color, sampler_desc->border_color,
 993                 sizeof(gl_tex->sampler_desc.border_color));
 994     }
 995
 996     state = sampler_desc->mag_filter;
 997     if (state != gl_tex->sampler_desc.mag_filter)
 998     {
 999         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAG_FILTER, wined3d_gl_mag_filter(state));
1000         gl_tex->sampler_desc.mag_filter = state;
1001     }
1002
1003     if (sampler_desc->min_filter != gl_tex->sampler_desc.min_filter
1004             || sampler_desc->mip_filter != gl_tex->sampler_desc.mip_filter)
1005     {
1006         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
1007                 wined3d_gl_min_mip_filter(sampler_desc->min_filter, sampler_desc->mip_filter));
1008         gl_tex->sampler_desc.min_filter = sampler_desc->min_filter;
1009         gl_tex->sampler_desc.mip_filter = sampler_desc->mip_filter;
1010     }
1011
1012     state = sampler_desc->max_anisotropy;
1013     if (state != gl_tex->sampler_desc.max_anisotropy)
1014     {
1015         if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC])
1016             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_MAX_ANISOTROPY, state);
1017         else
1018             WARN("Anisotropic filtering not supported.\n");
1019         gl_tex->sampler_desc.max_anisotropy = state;
1020     }
1021
1022     if (!sampler_desc->srgb_decode != !gl_tex->sampler_desc.srgb_decode
1023             && (context->d3d_info->wined3d_creation_flags & WINED3D_SRGB_READ_WRITE_CONTROL)
1024             && gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
1025     {
1026         gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_SRGB_DECODE_EXT,
1027                 sampler_desc->srgb_decode ? GL_DECODE_EXT : GL_SKIP_DECODE_EXT);
1028         gl_tex->sampler_desc.srgb_decode = sampler_desc->srgb_decode;
1029     }
1030
1031     if (!sampler_desc->compare != !gl_tex->sampler_desc.compare)
1032     {
1033         if (sampler_desc->compare)
1034             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB);
1035         else
1036             gl_info->gl_ops.gl.p_glTexParameteri(target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE);
1037         gl_tex->sampler_desc.compare = sampler_desc->compare;
1038     }
1039
1040     checkGLcall("Texture parameter application");
1041
1042     if (gl_info->supported[EXT_TEXTURE_LOD_BIAS])
1043     {
1044         gl_info->gl_ops.gl.p_glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT,
1045                 GL_TEXTURE_LOD_BIAS_EXT, sampler_desc->lod_bias);
1046         checkGLcall("glTexEnvf(GL_TEXTURE_LOD_BIAS_EXT, ...)");
1047     }
1048 }
1049
1050 ULONG CDECL wined3d_texture_incref(struct wined3d_texture *texture)
1051 {
1052     ULONG refcount;
1053
1054     TRACE("texture %p, swapchain %p.\n", texture, texture->swapchain);
1055
1056     if (texture->swapchain)
1057         return wined3d_swapchain_incref(texture->swapchain);
1058
1059     refcount = InterlockedIncrement(&texture->resource.ref);
1060     TRACE("%p increasing refcount to %u.\n", texture, refcount);
1061
1062     return refcount;
1063 }
1064
1065 static void wined3d_texture_cleanup_sync(struct wined3d_texture *texture)
1066 {
1067     wined3d_texture_sub_resources_destroyed(texture);
1068     resource_cleanup(&texture->resource);
1069     wined3d_resource_wait_idle(&texture->resource);
1070     wined3d_texture_cleanup(texture);
1071 }
1072
1073 static void wined3d_texture_destroy_object(void *object)
1074 {
1075     wined3d_texture_cleanup(object);
1076     heap_free(object);
1077 }
1078
1079 ULONG CDECL wined3d_texture_decref(struct wined3d_texture *texture)
1080 {
1081     ULONG refcount;
1082
1083     TRACE("texture %p, swapchain %p.\n", texture, texture->swapchain);
1084
1085     if (texture->swapchain)
1086         return wined3d_swapchain_decref(texture->swapchain);
1087
1088     refcount = InterlockedDecrement(&texture->resource.ref);
1089     TRACE("%p decreasing refcount to %u.\n", texture, refcount);
1090
1091     if (!refcount)
1092     {
1093         /* Wait for the texture to become idle if it's using user memory,
1094          * since the application is allowed to free that memory once the
1095          * texture is destroyed. Note that this implies that
1096          * wined3d_texture_destroy_object() can't access that memory either. */
1097         if (texture->user_memory)
1098             wined3d_resource_wait_idle(&texture->resource);
1099         wined3d_texture_sub_resources_destroyed(texture);
1100         texture->resource.parent_ops->wined3d_object_destroyed(texture->resource.parent);
1101         resource_cleanup(&texture->resource);
1102         wined3d_cs_destroy_object(texture->resource.device->cs, wined3d_texture_destroy_object, texture);
1103     }
1104
1105     return refcount;
1106 }
1107
1108 struct wined3d_resource * CDECL wined3d_texture_get_resource(struct wined3d_texture *texture)
1109 {
1110     TRACE("texture %p.\n", texture);
1111
1112     return &texture->resource;
1113 }
1114
1115 static BOOL color_key_equal(const struct wined3d_color_key *c1, struct wined3d_color_key *c2)
1116 {
1117     return c1->color_space_low_value == c2->color_space_low_value
1118             && c1->color_space_high_value == c2->color_space_high_value;
1119 }
1120
1121 /* Context activation is done by the caller */
1122 void wined3d_texture_load(struct wined3d_texture *texture,
1123         struct wined3d_context *context, BOOL srgb)
1124 {
1125     UINT sub_count = texture->level_count * texture->layer_count;
1126     const struct wined3d_d3d_info *d3d_info = context->d3d_info;
1127     DWORD flag;
1128     UINT i;
1129
1130     TRACE("texture %p, context %p, srgb %#x.\n", texture, context, srgb);
1131
1132     if (!needs_separate_srgb_gl_texture(context, texture))
1133         srgb = FALSE;
1134
1135     if (srgb)
1136         flag = WINED3D_TEXTURE_SRGB_VALID;
1137     else
1138         flag = WINED3D_TEXTURE_RGB_VALID;
1139
1140     if (!d3d_info->shader_color_key
1141             && (!(texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY)
1142             != !(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1143             || (texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY
1144             && !color_key_equal(&texture->async.gl_color_key, &texture->async.src_blt_color_key))))
1145     {
1146         unsigned int sub_count = texture->level_count * texture->layer_count;
1147         unsigned int i;
1148
1149         TRACE("Reloading because of color key value change.\n");
1150         for (i = 0; i < sub_count; i++)
1151         {
1152             if (!wined3d_texture_load_location(texture, i, context, texture->resource.map_binding))
1153                 ERR("Failed to load location %s.\n", wined3d_debug_location(texture->resource.map_binding));
1154             else
1155                 wined3d_texture_invalidate_location(texture, i, ~texture->resource.map_binding);
1156         }
1157
1158         texture->async.gl_color_key = texture->async.src_blt_color_key;
1159     }
1160
1161     if (texture->flags & flag)
1162     {
1163         TRACE("Texture %p not dirty, nothing to do.\n", texture);
1164         return;
1165     }
1166
1167     /* Reload the surfaces if the texture is marked dirty. */
1168     for (i = 0; i < sub_count; ++i)
1169     {
1170         if (!wined3d_texture_load_location(texture, i, context,
1171                 srgb ? WINED3D_LOCATION_TEXTURE_SRGB : WINED3D_LOCATION_TEXTURE_RGB))
1172             ERR("Failed to load location (srgb %#x).\n", srgb);
1173     }
1174     texture->flags |= flag;
1175 }
1176
1177 void * CDECL wined3d_texture_get_parent(const struct wined3d_texture *texture)
1178 {
1179     TRACE("texture %p.\n", texture);
1180
1181     return texture->resource.parent;
1182 }
1183
1184 HRESULT wined3d_texture_check_box_dimensions(const struct wined3d_texture *texture,
1185         unsigned int level, const struct wined3d_box *box)
1186 {
1187     const struct wined3d_format *format = texture->resource.format;
1188     unsigned int width_mask, height_mask, width, height, depth;
1189
1190     width = wined3d_texture_get_level_width(texture, level);
1191     height = wined3d_texture_get_level_height(texture, level);
1192     depth = wined3d_texture_get_level_depth(texture, level);
1193
1194     if (box->left >= box->right || box->right > width
1195             || box->top >= box->bottom || box->bottom > height
1196             || box->front >= box->back || box->back > depth)
1197     {
1198         WARN("Box %s is invalid.\n", debug_box(box));
1199         return WINEDDERR_INVALIDRECT;
1200     }
1201
1202     if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS)
1203     {
1204         /* This assumes power of two block sizes, but NPOT block sizes would
1205          * be silly anyway.
1206          *
1207          * This also assumes that the format's block depth is 1. */
1208         width_mask = format->block_width - 1;
1209         height_mask = format->block_height - 1;
1210
1211         if ((box->left & width_mask) || (box->top & height_mask)
1212                 || (box->right & width_mask && box->right != width)
1213                 || (box->bottom & height_mask && box->bottom != height))
1214         {
1215             WARN("Box %s is misaligned for %ux%u blocks.\n",
1216                     debug_box(box), format->block_width, format->block_height);
1217             return WINED3DERR_INVALIDCALL;
1218         }
1219     }
1220
1221     return WINED3D_OK;
1222 }
1223
1224 void CDECL wined3d_texture_get_pitch(const struct wined3d_texture *texture,
1225         unsigned int level, unsigned int *row_pitch, unsigned int *slice_pitch)
1226 {
1227     const struct wined3d_resource *resource = &texture->resource;
1228     unsigned int width = wined3d_texture_get_level_width(texture, level);
1229     unsigned int height = wined3d_texture_get_level_height(texture, level);
1230
1231     if (texture->row_pitch)
1232     {
1233         *row_pitch = texture->row_pitch;
1234         *slice_pitch = texture->slice_pitch;
1235         return;
1236     }
1237
1238     wined3d_format_calculate_pitch(resource->format, resource->device->surface_alignment,
1239             width, height, row_pitch, slice_pitch);
1240 }
1241
1242 DWORD CDECL wined3d_texture_set_lod(struct wined3d_texture *texture, DWORD lod)
1243 {
1244     DWORD old = texture->lod;
1245
1246     TRACE("texture %p, lod %u.\n", texture, lod);
1247
1248     /* The d3d9:texture test shows that SetLOD is ignored on non-managed
1249      * textures. The call always returns 0, and GetLOD always returns 0. */
1250     if (!wined3d_resource_access_is_managed(texture->resource.access))
1251     {
1252         TRACE("Ignoring LOD on texture with resource access %s.\n",
1253                 wined3d_debug_resource_access(texture->resource.access));
1254         return 0;
1255     }
1256
1257     if (lod >= texture->level_count)
1258         lod = texture->level_count - 1;
1259
1260     if (texture->lod != lod)
1261     {
1262         struct wined3d_device *device = texture->resource.device;
1263
1264         wined3d_resource_wait_idle(&texture->resource);
1265         texture->lod = lod;
1266
1267         texture->texture_rgb.base_level = ~0u;
1268         texture->texture_srgb.base_level = ~0u;
1269         if (texture->resource.bind_count)
1270             wined3d_cs_emit_set_sampler_state(device->cs, texture->sampler, WINED3D_SAMP_MAX_MIP_LEVEL,
1271                     device->state.sampler_states[texture->sampler][WINED3D_SAMP_MAX_MIP_LEVEL]);
1272     }
1273
1274     return old;
1275 }
1276
1277 DWORD CDECL wined3d_texture_get_lod(const struct wined3d_texture *texture)
1278 {
1279     TRACE("texture %p, returning %u.\n", texture, texture->lod);
1280
1281     return texture->lod;
1282 }
1283
1284 DWORD CDECL wined3d_texture_get_level_count(const struct wined3d_texture *texture)
1285 {
1286     TRACE("texture %p, returning %u.\n", texture, texture->level_count);
1287
1288     return texture->level_count;
1289 }
1290
1291 HRESULT CDECL wined3d_texture_set_color_key(struct wined3d_texture *texture,
1292         DWORD flags, const struct wined3d_color_key *color_key)
1293 {
1294     struct wined3d_device *device = texture->resource.device;
1295     static const DWORD all_flags = WINED3D_CKEY_DST_BLT | WINED3D_CKEY_DST_OVERLAY
1296             | WINED3D_CKEY_SRC_BLT | WINED3D_CKEY_SRC_OVERLAY;
1297
1298     TRACE("texture %p, flags %#x, color_key %p.\n", texture, flags, color_key);
1299
1300     if (flags & ~all_flags)
1301     {
1302         WARN("Invalid flags passed, returning WINED3DERR_INVALIDCALL.\n");
1303         return WINED3DERR_INVALIDCALL;
1304     }
1305
1306     wined3d_cs_emit_set_color_key(device->cs, texture, flags, color_key);
1307
1308     return WINED3D_OK;
1309 }
1310
1311 /* In D3D the depth stencil dimensions have to be greater than or equal to the
1312  * render target dimensions. With FBOs, the dimensions have to be an exact match. */
1313 /* TODO: We should synchronize the renderbuffer's content with the texture's content. */
1314 /* Context activation is done by the caller. */
1315 void wined3d_texture_set_compatible_renderbuffer(struct wined3d_texture *texture,
1316         unsigned int level, const struct wined3d_rendertarget_info *rt)
1317 {
1318     struct wined3d_renderbuffer_entry *entry;
1319     const struct wined3d_gl_info *gl_info;
1320     unsigned int src_width, src_height;
1321     unsigned int width, height;
1322     GLuint renderbuffer = 0;
1323
1324     gl_info = &texture->resource.device->adapter->gl_info;
1325     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
1326         return;
1327
1328     if (rt && rt->resource->format->id != WINED3DFMT_NULL)
1329     {
1330         struct wined3d_texture *rt_texture;
1331         unsigned int rt_level;
1332
1333         if (rt->resource->type == WINED3D_RTYPE_BUFFER)
1334         {
1335             FIXME("Unsupported resource type %s.\n", debug_d3dresourcetype(rt->resource->type));
1336             return;
1337         }
1338         rt_texture = wined3d_texture_from_resource(rt->resource);
1339         rt_level = rt->sub_resource_idx % rt_texture->level_count;
1340
1341         width = wined3d_texture_get_level_pow2_width(rt_texture, rt_level);
1342         height = wined3d_texture_get_level_pow2_height(rt_texture, rt_level);
1343     }
1344     else
1345     {
1346         width = wined3d_texture_get_level_pow2_width(texture, level);
1347         height = wined3d_texture_get_level_pow2_height(texture, level);
1348     }
1349
1350     src_width = wined3d_texture_get_level_pow2_width(texture, level);
1351     src_height = wined3d_texture_get_level_pow2_height(texture, level);
1352
1353     /* A depth stencil smaller than the render target is not valid */
1354     if (width > src_width || height > src_height)
1355         return;
1356
1357     /* Remove any renderbuffer set if the sizes match */
1358     if (width == src_width && height == src_height)
1359     {
1360         texture->current_renderbuffer = NULL;
1361         return;
1362     }
1363
1364     /* Look if we've already got a renderbuffer of the correct dimensions */
1365     LIST_FOR_EACH_ENTRY(entry, &texture->renderbuffers, struct wined3d_renderbuffer_entry, entry)
1366     {
1367         if (entry->width == width && entry->height == height)
1368         {
1369             renderbuffer = entry->id;
1370             texture->current_renderbuffer = entry;
1371             break;
1372         }
1373     }
1374
1375     if (!renderbuffer)
1376     {
1377         gl_info->fbo_ops.glGenRenderbuffers(1, &renderbuffer);
1378         gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer);
1379         gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER,
1380                 texture->resource.format->glInternal, width, height);
1381
1382         entry = heap_alloc(sizeof(*entry));
1383         entry->width = width;
1384         entry->height = height;
1385         entry->id = renderbuffer;
1386         list_add_head(&texture->renderbuffers, &entry->entry);
1387
1388         texture->current_renderbuffer = entry;
1389     }
1390
1391     checkGLcall("set_compatible_renderbuffer");
1392 }
1393
1394 HRESULT CDECL wined3d_texture_update_desc(struct wined3d_texture *texture, UINT width, UINT height,
1395         enum wined3d_format_id format_id, enum wined3d_multisample_type multisample_type,
1396         UINT multisample_quality, void *mem, UINT pitch)
1397 {
1398     struct wined3d_device *device = texture->resource.device;
1399     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
1400     const struct wined3d_format *format = wined3d_get_format(gl_info, format_id, texture->resource.usage);
1401     UINT resource_size = wined3d_format_calculate_size(format, device->surface_alignment, width, height, 1);
1402     struct wined3d_texture_sub_resource *sub_resource;
1403     DWORD valid_location = 0;
1404     BOOL create_dib = FALSE;
1405
1406     TRACE("texture %p, width %u, height %u, format %s, multisample_type %#x, multisample_quality %u, "
1407             "mem %p, pitch %u.\n",
1408             texture, width, height, debug_d3dformat(format_id), multisample_type, multisample_quality, mem, pitch);
1409
1410     if (!resource_size)
1411         return WINED3DERR_INVALIDCALL;
1412
1413     if (texture->level_count * texture->layer_count > 1)
1414     {
1415         WARN("Texture has multiple sub-resources, not supported.\n");
1416         return WINED3DERR_INVALIDCALL;
1417     }
1418
1419     if (texture->resource.type != WINED3D_RTYPE_TEXTURE_2D)
1420     {
1421         WARN("Not supported on %s.\n", debug_d3dresourcetype(texture->resource.type));
1422         return WINED3DERR_INVALIDCALL;
1423     }
1424
1425     if (texture->resource.map_count)
1426     {
1427         WARN("Texture is mapped.\n");
1428         return WINED3DERR_INVALIDCALL;
1429     }
1430
1431     /* We have no way of supporting a pitch that is not a multiple of the pixel
1432      * byte width short of uploading the texture row-by-row.
1433      * Fortunately that's not an issue since D3D9Ex doesn't allow a custom pitch
1434      * for user-memory textures (it always expects packed data) while DirectDraw
1435      * requires a 4-byte aligned pitch and doesn't support texture formats
1436      * larger than 4 bytes per pixel nor any format using 3 bytes per pixel.
1437      * This check is here to verify that the assumption holds. */
1438     if (pitch % texture->resource.format->byte_count)
1439     {
1440         WARN("Pitch unsupported, not a multiple of the texture format byte width.\n");
1441         return WINED3DERR_INVALIDCALL;
1442     }
1443
1444     if (device->d3d_initialized)
1445         wined3d_cs_emit_unload_resource(device->cs, &texture->resource);
1446     wined3d_resource_wait_idle(&texture->resource);
1447
1448     sub_resource = &texture->sub_resources[0];
1449     if (texture->dc_info && texture->dc_info[0].dc)
1450     {
1451         struct wined3d_texture_idx texture_idx = {texture, 0};
1452
1453         wined3d_cs_destroy_object(device->cs, wined3d_texture_destroy_dc, &texture_idx);
1454         device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1455         create_dib = TRUE;
1456     }
1457
1458     wined3d_resource_free_sysmem(&texture->resource);
1459
1460     if ((texture->row_pitch = pitch))
1461         texture->slice_pitch = height * pitch;
1462     else
1463         /* User memory surfaces don't have the regular surface alignment. */
1464         wined3d_format_calculate_pitch(format, 1, width, height,
1465                 &texture->row_pitch, &texture->slice_pitch);
1466
1467     texture->resource.format = format;
1468     texture->resource.multisample_type = multisample_type;
1469     texture->resource.multisample_quality = multisample_quality;
1470     texture->resource.width = width;
1471     texture->resource.height = height;
1472     texture->resource.size = texture->slice_pitch;
1473     sub_resource->size = texture->slice_pitch;
1474     sub_resource->locations = WINED3D_LOCATION_DISCARDED;
1475
1476     if (multisample_type && gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
1477         texture->target = GL_TEXTURE_2D_MULTISAMPLE;
1478     else
1479         texture->target = GL_TEXTURE_2D;
1480
1481     if (((width & (width - 1)) || (height & (height - 1))) && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]
1482             && !gl_info->supported[ARB_TEXTURE_RECTANGLE] && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
1483     {
1484         texture->flags |= WINED3D_TEXTURE_COND_NP2_EMULATED;
1485         texture->pow2_width = texture->pow2_height = 1;
1486         while (texture->pow2_width < width)
1487             texture->pow2_width <<= 1;
1488         while (texture->pow2_height < height)
1489             texture->pow2_height <<= 1;
1490     }
1491     else
1492     {
1493         texture->flags &= ~WINED3D_TEXTURE_COND_NP2_EMULATED;
1494         texture->pow2_width = width;
1495         texture->pow2_height = height;
1496     }
1497
1498     if ((texture->user_memory = mem))
1499     {
1500         texture->resource.map_binding = WINED3D_LOCATION_USER_MEMORY;
1501         valid_location = WINED3D_LOCATION_USER_MEMORY;
1502     }
1503     else
1504     {
1505         wined3d_texture_prepare_location(texture, 0, NULL, WINED3D_LOCATION_SYSMEM);
1506         valid_location = WINED3D_LOCATION_SYSMEM;
1507     }
1508
1509     /* The format might be changed to a format that needs conversion.
1510      * If the surface didn't use PBOs previously but could now, don't
1511      * change it - whatever made us not use PBOs might come back, e.g.
1512      * color keys. */
1513     if (texture->resource.map_binding == WINED3D_LOCATION_BUFFER && !wined3d_texture_use_pbo(texture, gl_info))
1514         texture->resource.map_binding = WINED3D_LOCATION_SYSMEM;
1515
1516     wined3d_texture_validate_location(texture, 0, valid_location);
1517     wined3d_texture_invalidate_location(texture, 0, ~valid_location);
1518
1519     if (create_dib)
1520     {
1521         struct wined3d_texture_idx texture_idx = {texture, 0};
1522
1523         wined3d_cs_init_object(device->cs, wined3d_texture_create_dc, &texture_idx);
1524         device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
1525     }
1526
1527     return WINED3D_OK;
1528 }
1529
1530 /* Context activation is done by the caller. */
1531 static void wined3d_texture_prepare_buffer_object(struct wined3d_texture *texture,
1532         unsigned int sub_resource_idx, const struct wined3d_gl_info *gl_info)
1533 {
1534     struct wined3d_texture_sub_resource *sub_resource;
1535
1536     sub_resource = &texture->sub_resources[sub_resource_idx];
1537     if (sub_resource->buffer_object)
1538         return;
1539
1540     GL_EXTCALL(glGenBuffers(1, &sub_resource->buffer_object));
1541     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, sub_resource->buffer_object));
1542     GL_EXTCALL(glBufferData(GL_PIXEL_UNPACK_BUFFER, sub_resource->size, NULL, GL_STREAM_DRAW));
1543     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
1544     checkGLcall("Create buffer object");
1545
1546     TRACE("Created buffer object %u for texture %p, sub-resource %u.\n",
1547             sub_resource->buffer_object, texture, sub_resource_idx);
1548 }
1549
1550 static void wined3d_texture_force_reload(struct wined3d_texture *texture)
1551 {
1552     unsigned int sub_count = texture->level_count * texture->layer_count;
1553     unsigned int i;
1554
1555     texture->flags &= ~(WINED3D_TEXTURE_RGB_ALLOCATED | WINED3D_TEXTURE_SRGB_ALLOCATED
1556             | WINED3D_TEXTURE_CONVERTED);
1557     texture->async.flags &= ~WINED3D_TEXTURE_ASYNC_COLOR_KEY;
1558     for (i = 0; i < sub_count; ++i)
1559     {
1560         wined3d_texture_invalidate_location(texture, i,
1561                 WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB);
1562     }
1563 }
1564
1565 /* Context activation is done by the caller. */
1566 void wined3d_texture_prepare_texture(struct wined3d_texture *texture, struct wined3d_context *context, BOOL srgb)
1567 {
1568     DWORD alloc_flag = srgb ? WINED3D_TEXTURE_SRGB_ALLOCATED : WINED3D_TEXTURE_RGB_ALLOCATED;
1569     const struct wined3d_format *format = texture->resource.format;
1570     const struct wined3d_d3d_info *d3d_info = context->d3d_info;
1571     const struct wined3d_gl_info *gl_info = context->gl_info;
1572     const struct wined3d_color_key_conversion *conversion;
1573     GLenum internal;
1574
1575     TRACE("texture %p, context %p, format %s.\n", texture, context, debug_d3dformat(format->id));
1576
1577     if (!d3d_info->shader_color_key
1578             && !(texture->async.flags & WINED3D_TEXTURE_ASYNC_COLOR_KEY)
1579             != !(texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT))
1580     {
1581         wined3d_texture_force_reload(texture);
1582
1583         if (texture->async.color_key_flags & WINED3D_CKEY_SRC_BLT)
1584             texture->async.flags |= WINED3D_TEXTURE_ASYNC_COLOR_KEY;
1585     }
1586
1587     if (texture->flags & alloc_flag)
1588         return;
1589
1590     if (format->conv_byte_count)
1591     {
1592         texture->flags |= WINED3D_TEXTURE_CONVERTED;
1593     }
1594     else if ((conversion = wined3d_format_get_color_key_conversion(texture, TRUE)))
1595     {
1596         texture->flags |= WINED3D_TEXTURE_CONVERTED;
1597         format = wined3d_get_format(gl_info, conversion->dst_format, texture->resource.usage);
1598         TRACE("Using format %s for color key conversion.\n", debug_d3dformat(format->id));
1599     }
1600
1601     wined3d_texture_bind_and_dirtify(texture, context, srgb);
1602
1603     if (srgb)
1604         internal = format->glGammaInternal;
1605     else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET
1606             && wined3d_resource_is_offscreen(&texture->resource))
1607         internal = format->rtInternal;
1608     else
1609         internal = format->glInternal;
1610
1611     if (!internal)
1612         FIXME("No GL internal format for format %s.\n", debug_d3dformat(format->id));
1613
1614     TRACE("internal %#x, format %#x, type %#x.\n", internal, format->glFormat, format->glType);
1615
1616     if (wined3d_texture_use_immutable_storage(texture, gl_info))
1617         wined3d_texture_allocate_gl_immutable_storage(texture, internal, gl_info);
1618     else
1619         wined3d_texture_allocate_gl_mutable_storage(texture, internal, format, gl_info);
1620     texture->flags |= alloc_flag;
1621 }
1622
1623 static void wined3d_texture_prepare_rb(struct wined3d_texture *texture,
1624         const struct wined3d_gl_info *gl_info, BOOL multisample)
1625 {
1626     const struct wined3d_format *format = texture->resource.format;
1627
1628     if (multisample)
1629     {
1630         DWORD samples;
1631
1632         if (texture->rb_multisample)
1633             return;
1634
1635         samples = wined3d_texture_get_gl_sample_count(texture);
1636
1637         gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_multisample);
1638         gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_multisample);
1639         gl_info->fbo_ops.glRenderbufferStorageMultisample(GL_RENDERBUFFER, samples,
1640                 format->glInternal, texture->resource.width, texture->resource.height);
1641         checkGLcall("glRenderbufferStorageMultisample()");
1642         TRACE("Created multisample rb %u.\n", texture->rb_multisample);
1643     }
1644     else
1645     {
1646         if (texture->rb_resolved)
1647             return;
1648
1649         gl_info->fbo_ops.glGenRenderbuffers(1, &texture->rb_resolved);
1650         gl_info->fbo_ops.glBindRenderbuffer(GL_RENDERBUFFER, texture->rb_resolved);
1651         gl_info->fbo_ops.glRenderbufferStorage(GL_RENDERBUFFER, format->glInternal,
1652                 texture->resource.width, texture->resource.height);
1653         checkGLcall("glRenderbufferStorage()");
1654         TRACE("Created resolved rb %u.\n", texture->rb_resolved);
1655     }
1656 }
1657
1658 /* Context activation is done by the caller. Context may be NULL in
1659  * WINED3D_NO3D mode. */
1660 BOOL wined3d_texture_prepare_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1661         struct wined3d_context *context, DWORD location)
1662 {
1663     switch (location)
1664     {
1665         case WINED3D_LOCATION_SYSMEM:
1666             if (texture->resource.heap_memory)
1667                 return TRUE;
1668
1669             if (!wined3d_resource_allocate_sysmem(&texture->resource))
1670             {
1671                 ERR("Failed to allocate system memory.\n");
1672                 return FALSE;
1673             }
1674             return TRUE;
1675
1676         case WINED3D_LOCATION_USER_MEMORY:
1677             if (!texture->user_memory)
1678                 ERR("Map binding is set to WINED3D_LOCATION_USER_MEMORY but surface->user_memory is NULL.\n");
1679             return TRUE;
1680
1681         case WINED3D_LOCATION_BUFFER:
1682             wined3d_texture_prepare_buffer_object(texture, sub_resource_idx, context->gl_info);
1683             return TRUE;
1684
1685         case WINED3D_LOCATION_TEXTURE_RGB:
1686             wined3d_texture_prepare_texture(texture, context, FALSE);
1687             return TRUE;
1688
1689         case WINED3D_LOCATION_TEXTURE_SRGB:
1690             wined3d_texture_prepare_texture(texture, context, TRUE);
1691             return TRUE;
1692
1693         case WINED3D_LOCATION_DRAWABLE:
1694             if (!texture->swapchain && wined3d_settings.offscreen_rendering_mode != ORM_BACKBUFFER)
1695                 ERR("Texture %p does not have a drawable.\n", texture);
1696             return TRUE;
1697
1698         case WINED3D_LOCATION_RB_MULTISAMPLE:
1699             wined3d_texture_prepare_rb(texture, context->gl_info, TRUE);
1700             return TRUE;
1701
1702         case WINED3D_LOCATION_RB_RESOLVED:
1703             wined3d_texture_prepare_rb(texture, context->gl_info, FALSE);
1704             return TRUE;
1705
1706         default:
1707             ERR("Invalid location %s.\n", wined3d_debug_location(location));
1708             return FALSE;
1709     }
1710 }
1711
1712 static struct wined3d_texture_sub_resource *wined3d_texture_get_sub_resource(struct wined3d_texture *texture,
1713         unsigned int sub_resource_idx)
1714 {
1715     UINT sub_count = texture->level_count * texture->layer_count;
1716
1717     TRACE("texture %p, sub_resource_idx %u.\n", texture, sub_resource_idx);
1718
1719     if (sub_resource_idx >= sub_count)
1720     {
1721         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
1722         return NULL;
1723     }
1724
1725     return &texture->sub_resources[sub_resource_idx];
1726 }
1727
1728 HRESULT CDECL wined3d_texture_add_dirty_region(struct wined3d_texture *texture,
1729         UINT layer, const struct wined3d_box *dirty_region)
1730 {
1731     TRACE("texture %p, layer %u, dirty_region %s.\n", texture, layer, debug_box(dirty_region));
1732
1733     if (layer >= texture->layer_count)
1734     {
1735         WARN("Invalid layer %u specified.\n", layer);
1736         return WINED3DERR_INVALIDCALL;
1737     }
1738
1739     if (dirty_region)
1740         FIXME("Ignoring dirty_region %s.\n", debug_box(dirty_region));
1741
1742     wined3d_cs_emit_add_dirty_texture_region(texture->resource.device->cs, texture, layer);
1743
1744     return WINED3D_OK;
1745 }
1746
1747 void wined3d_texture_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1748         const struct wined3d_context *context, const struct wined3d_format *format, const struct wined3d_box *src_box,
1749         const struct wined3d_const_bo_address *data, unsigned int row_pitch, unsigned int slice_pitch,
1750         unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, BOOL srgb)
1751 {
1752     texture->texture_ops->texture_upload_data(texture, sub_resource_idx, context,
1753             format, src_box, data, row_pitch, slice_pitch, dst_x, dst_y, dst_z, srgb);
1754 }
1755
1756 /* This call just uploads data, the caller is responsible for binding the
1757  * correct texture. */
1758 /* Context activation is done by the caller. */
1759 static void texture2d_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1760         const struct wined3d_context *context, const struct wined3d_format *format, const struct wined3d_box *src_box,
1761         const struct wined3d_const_bo_address *data, unsigned int src_row_pitch, unsigned int src_slice_pitch,
1762         unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, BOOL srgb)
1763 {
1764     const struct wined3d_gl_info *gl_info = context->gl_info;
1765     unsigned int update_w = src_box->right - src_box->left;
1766     unsigned int update_h = src_box->bottom - src_box->top;
1767     unsigned int level, layer;
1768     GLenum target;
1769
1770     TRACE("texture %p, sub_resource_idx %u, context %p, format %s, src_box %s, data {%#x:%p}, "
1771             "src_row_pitch %#x, src_slice_pitch %#x, dst_x %u, dst_y %u, dst_z %u, srgb %#x.\n",
1772             texture, sub_resource_idx, context, debug_d3dformat(format->id), debug_box(src_box),
1773             data->buffer_object, data->addr, src_row_pitch, src_slice_pitch, dst_x, dst_y, dst_z, srgb);
1774
1775     if (texture->sub_resources[sub_resource_idx].map_count)
1776     {
1777         WARN("Uploading a texture that is currently mapped, setting WINED3D_TEXTURE_PIN_SYSMEM.\n");
1778         texture->flags |= WINED3D_TEXTURE_PIN_SYSMEM;
1779     }
1780
1781     if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_HEIGHT_SCALE)
1782     {
1783         update_h *= format->height_scale.numerator;
1784         update_h /= format->height_scale.denominator;
1785     }
1786
1787     if (data->buffer_object)
1788     {
1789         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, data->buffer_object));
1790         checkGLcall("glBindBuffer");
1791     }
1792
1793     target = wined3d_texture_get_sub_resource_target(texture, sub_resource_idx);
1794     level = sub_resource_idx % texture->level_count;
1795     layer = sub_resource_idx / texture->level_count;
1796
1797     if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_COMPRESSED)
1798     {
1799         unsigned int dst_row_pitch, dst_slice_pitch;
1800         const BYTE *addr = data->addr;
1801         GLenum internal;
1802
1803         addr += (src_box->top / format->block_height) * src_row_pitch;
1804         addr += (src_box->left / format->block_width) * format->block_byte_count;
1805
1806         if (srgb)
1807             internal = format->glGammaInternal;
1808         else if (texture->resource.usage & WINED3DUSAGE_RENDERTARGET
1809                 && wined3d_resource_is_offscreen(&texture->resource))
1810             internal = format->rtInternal;
1811         else
1812             internal = format->glInternal;
1813
1814         wined3d_format_calculate_pitch(format, 1, update_w, update_h, &dst_row_pitch, &dst_slice_pitch);
1815
1816         TRACE("Uploading compressed data, target %#x, level %u, layer %u, x %d, y %d, w %u, h %u, "
1817                 "format %#x, image_size %#x, addr %p.\n",
1818                 target, level, layer, dst_x, dst_y,
1819                 update_w, update_h, internal, dst_slice_pitch, addr);
1820
1821         if (dst_row_pitch == src_row_pitch)
1822         {
1823             if (target == GL_TEXTURE_2D_ARRAY)
1824             {
1825                 GL_EXTCALL(glCompressedTexSubImage3D(target, level, dst_x, dst_y,
1826                         layer, update_w, update_h, 1, internal, dst_slice_pitch, addr));
1827             }
1828             else
1829             {
1830                 GL_EXTCALL(glCompressedTexSubImage2D(target, level, dst_x, dst_y,
1831                         update_w, update_h, internal, dst_slice_pitch, addr));
1832             }
1833         }
1834         else
1835         {
1836             UINT row_count = (update_h + format->block_height - 1) / format->block_height;
1837             UINT row, y;
1838
1839             /* glCompressedTexSubImage2D() ignores pixel store state, so we
1840              * can't use the unpack row length like for glTexSubImage2D. */
1841             for (row = 0, y = dst_y; row < row_count; ++row)
1842             {
1843                 if (target == GL_TEXTURE_2D_ARRAY)
1844                 {
1845                     GL_EXTCALL(glCompressedTexSubImage3D(target, level, dst_x, y,
1846                             layer, update_w, format->block_height, 1, internal, dst_row_pitch, addr));
1847                 }
1848                 else
1849                 {
1850                     GL_EXTCALL(glCompressedTexSubImage2D(target, level, dst_x, y,
1851                             update_w, format->block_height, internal, dst_row_pitch, addr));
1852                 }
1853
1854                 y += format->block_height;
1855                 addr += src_row_pitch;
1856             }
1857         }
1858         checkGLcall("Upload compressed texture data");
1859     }
1860     else
1861     {
1862         const BYTE *addr = data->addr;
1863
1864         addr += src_box->top * src_row_pitch;
1865         addr += src_box->left * format->byte_count;
1866
1867         TRACE("Uploading data, target %#x, level %u, layer %u, x %d, y %d, w %u, h %u, "
1868                 "format %#x, type %#x, addr %p.\n",
1869                 target, level, layer, dst_x, dst_y,
1870                 update_w, update_h, format->glFormat, format->glType, addr);
1871
1872         gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, src_row_pitch / format->byte_count);
1873         if (target == GL_TEXTURE_2D_ARRAY)
1874         {
1875             GL_EXTCALL(glTexSubImage3D(target, level, dst_x, dst_y,
1876                     layer, update_w, update_h, 1, format->glFormat, format->glType, addr));
1877         }
1878         else
1879         {
1880             gl_info->gl_ops.gl.p_glTexSubImage2D(target, level, dst_x, dst_y,
1881                     update_w, update_h, format->glFormat, format->glType, addr);
1882         }
1883         gl_info->gl_ops.gl.p_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
1884         checkGLcall("Upload texture data");
1885     }
1886
1887     if (data->buffer_object)
1888     {
1889         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
1890         checkGLcall("glBindBuffer");
1891     }
1892
1893     if (wined3d_settings.strict_draw_ordering)
1894         gl_info->gl_ops.gl.p_glFlush();
1895
1896     if (gl_info->quirks & WINED3D_QUIRK_FBO_TEX_UPDATE)
1897     {
1898         struct wined3d_device *device = texture->resource.device;
1899         unsigned int i;
1900
1901         for (i = 0; i < device->context_count; ++i)
1902         {
1903             context_texture_update(device->contexts[i], texture);
1904         }
1905     }
1906 }
1907
1908 /* Context activation is done by the caller. Context may be NULL in ddraw-only mode. */
1909 static BOOL texture2d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
1910         struct wined3d_context *context, DWORD location)
1911 {
1912     TRACE("texture %p, sub_resource_idx %u, context %p, location %s.\n",
1913             texture, sub_resource_idx, context, wined3d_debug_location(location));
1914
1915     switch (location)
1916     {
1917         case WINED3D_LOCATION_USER_MEMORY:
1918         case WINED3D_LOCATION_SYSMEM:
1919         case WINED3D_LOCATION_BUFFER:
1920             return texture2d_load_sysmem(texture, sub_resource_idx, context, location);
1921
1922         case WINED3D_LOCATION_DRAWABLE:
1923             return texture2d_load_drawable(texture, sub_resource_idx, context);
1924
1925         case WINED3D_LOCATION_RB_RESOLVED:
1926         case WINED3D_LOCATION_RB_MULTISAMPLE:
1927             return texture2d_load_renderbuffer(texture, sub_resource_idx, context, location);
1928
1929         case WINED3D_LOCATION_TEXTURE_RGB:
1930         case WINED3D_LOCATION_TEXTURE_SRGB:
1931             return texture2d_load_texture(texture, sub_resource_idx, context,
1932                     location == WINED3D_LOCATION_TEXTURE_SRGB);
1933
1934         default:
1935             ERR("Don't know how to handle location %#x.\n", location);
1936             return FALSE;
1937     }
1938 }
1939
1940 static const struct wined3d_texture_ops texture2d_ops =
1941 {
1942     texture2d_upload_data,
1943     texture2d_load_location,
1944 };
1945
1946 struct wined3d_texture * __cdecl wined3d_texture_from_resource(struct wined3d_resource *resource)
1947 {
1948     return texture_from_resource(resource);
1949 }
1950
1951 static ULONG texture_resource_incref(struct wined3d_resource *resource)
1952 {
1953     return wined3d_texture_incref(texture_from_resource(resource));
1954 }
1955
1956 static ULONG texture_resource_decref(struct wined3d_resource *resource)
1957 {
1958     return wined3d_texture_decref(texture_from_resource(resource));
1959 }
1960
1961 static void texture_resource_preload(struct wined3d_resource *resource)
1962 {
1963     struct wined3d_texture *texture = texture_from_resource(resource);
1964     struct wined3d_context *context;
1965
1966     context = context_acquire(resource->device, NULL, 0);
1967     wined3d_texture_load(texture, context, texture->flags & WINED3D_TEXTURE_IS_SRGB);
1968     context_release(context);
1969 }
1970
1971 static void wined3d_texture_unload(struct wined3d_resource *resource)
1972 {
1973     struct wined3d_texture *texture = texture_from_resource(resource);
1974     UINT sub_count = texture->level_count * texture->layer_count;
1975     struct wined3d_renderbuffer_entry *entry, *entry2;
1976     struct wined3d_device *device = resource->device;
1977     const struct wined3d_gl_info *gl_info;
1978     struct wined3d_context *context;
1979     UINT i;
1980
1981     TRACE("texture %p.\n", texture);
1982
1983     context = context_acquire(device, NULL, 0);
1984     gl_info = context->gl_info;
1985
1986     for (i = 0; i < sub_count; ++i)
1987     {
1988         struct wined3d_texture_sub_resource *sub_resource = &texture->sub_resources[i];
1989
1990         if (resource->access & WINED3D_RESOURCE_ACCESS_CPU
1991                 && wined3d_texture_load_location(texture, i, context, resource->map_binding))
1992         {
1993             wined3d_texture_invalidate_location(texture, i, ~resource->map_binding);
1994         }
1995         else
1996         {
1997             /* We should only get here on device reset/teardown for implicit
1998              * resources. */
1999             if (resource->access & WINED3D_RESOURCE_ACCESS_CPU
2000                     || resource->type != WINED3D_RTYPE_TEXTURE_2D)
2001                 ERR("Discarding %s %p sub-resource %u with resource access %s.\n",
2002                         debug_d3dresourcetype(resource->type), resource, i,
2003                         wined3d_debug_resource_access(resource->access));
2004             wined3d_texture_validate_location(texture, i, WINED3D_LOCATION_DISCARDED);
2005             wined3d_texture_invalidate_location(texture, i, ~WINED3D_LOCATION_DISCARDED);
2006         }
2007
2008         if (sub_resource->buffer_object)
2009             wined3d_texture_remove_buffer_object(texture, i, context->gl_info);
2010     }
2011
2012     LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &texture->renderbuffers, struct wined3d_renderbuffer_entry, entry)
2013     {
2014         context_gl_resource_released(device, entry->id, TRUE);
2015         gl_info->fbo_ops.glDeleteRenderbuffers(1, &entry->id);
2016         list_remove(&entry->entry);
2017         heap_free(entry);
2018     }
2019     list_init(&texture->renderbuffers);
2020     texture->current_renderbuffer = NULL;
2021
2022     context_release(context);
2023
2024     wined3d_texture_force_reload(texture);
2025     wined3d_texture_unload_gl_texture(texture);
2026 }
2027
2028 static HRESULT texture_resource_sub_resource_map(struct wined3d_resource *resource, unsigned int sub_resource_idx,
2029         struct wined3d_map_desc *map_desc, const struct wined3d_box *box, DWORD flags)
2030 {
2031     const struct wined3d_format *format = resource->format;
2032     struct wined3d_texture_sub_resource *sub_resource;
2033     struct wined3d_device *device = resource->device;
2034     unsigned int fmt_flags = resource->format_flags;
2035     struct wined3d_context *context = NULL;
2036     struct wined3d_texture *texture;
2037     struct wined3d_bo_address data;
2038     unsigned int texture_level;
2039     BYTE *base_memory;
2040     BOOL ret;
2041
2042     TRACE("resource %p, sub_resource_idx %u, map_desc %p, box %s, flags %#x.\n",
2043             resource, sub_resource_idx, map_desc, debug_box(box), flags);
2044
2045     texture = texture_from_resource(resource);
2046     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
2047         return E_INVALIDARG;
2048
2049     texture_level = sub_resource_idx % texture->level_count;
2050     if (box && FAILED(wined3d_texture_check_box_dimensions(texture, texture_level, box)))
2051     {
2052         WARN("Map box is invalid.\n");
2053         if (((fmt_flags & WINED3DFMT_FLAG_BLOCKS) && !(resource->access & WINED3D_RESOURCE_ACCESS_CPU))
2054                 || resource->type != WINED3D_RTYPE_TEXTURE_2D)
2055             return WINED3DERR_INVALIDCALL;
2056     }
2057
2058     if (texture->flags & WINED3D_TEXTURE_DC_IN_USE)
2059     {
2060         WARN("DC is in use.\n");
2061         return WINED3DERR_INVALIDCALL;
2062     }
2063
2064     if (sub_resource->map_count)
2065     {
2066         WARN("Sub-resource is already mapped.\n");
2067         return WINED3DERR_INVALIDCALL;
2068     }
2069
2070     if (device->d3d_initialized)
2071         context = context_acquire(device, NULL, 0);
2072
2073     if (flags & WINED3D_MAP_DISCARD)
2074     {
2075         TRACE("WINED3D_MAP_DISCARD flag passed, marking %s as up to date.\n",
2076                 wined3d_debug_location(resource->map_binding));
2077         if ((ret = wined3d_texture_prepare_location(texture, sub_resource_idx, context, resource->map_binding)))
2078             wined3d_texture_validate_location(texture, sub_resource_idx, resource->map_binding);
2079     }
2080     else
2081     {
2082         if (resource->usage & WINED3DUSAGE_DYNAMIC)
2083             WARN_(d3d_perf)("Mapping a dynamic texture without WINED3D_MAP_DISCARD.\n");
2084         ret = wined3d_texture_load_location(texture, sub_resource_idx, context, resource->map_binding);
2085     }
2086
2087     if (!ret)
2088     {
2089         ERR("Failed to prepare location.\n");
2090         context_release(context);
2091         return E_OUTOFMEMORY;
2092     }
2093
2094     if (flags & WINED3D_MAP_WRITE
2095             && (!(flags & WINED3D_MAP_NO_DIRTY_UPDATE) || (resource->usage & WINED3DUSAGE_DYNAMIC)))
2096         wined3d_texture_invalidate_location(texture, sub_resource_idx, ~resource->map_binding);
2097
2098     wined3d_texture_get_memory(texture, sub_resource_idx, &data, resource->map_binding);
2099     base_memory = context_map_bo_address(context, &data, sub_resource->size, GL_PIXEL_UNPACK_BUFFER, flags);
2100     TRACE("Base memory pointer %p.\n", base_memory);
2101
2102     if (context)
2103         context_release(context);
2104
2105     if (fmt_flags & WINED3DFMT_FLAG_BROKEN_PITCH)
2106     {
2107         map_desc->row_pitch = wined3d_texture_get_level_width(texture, texture_level) * format->byte_count;
2108         map_desc->slice_pitch = wined3d_texture_get_level_height(texture, texture_level) * map_desc->row_pitch;
2109     }
2110     else
2111     {
2112         wined3d_texture_get_pitch(texture, texture_level, &map_desc->row_pitch, &map_desc->slice_pitch);
2113     }
2114
2115     if (!box)
2116     {
2117         map_desc->data = base_memory;
2118     }
2119     else
2120     {
2121         if ((fmt_flags & (WINED3DFMT_FLAG_BLOCKS | WINED3DFMT_FLAG_BROKEN_PITCH)) == WINED3DFMT_FLAG_BLOCKS)
2122         {
2123             /* Compressed textures are block based, so calculate the offset of
2124              * the block that contains the top-left pixel of the mapped box. */
2125             map_desc->data = base_memory
2126                     + (box->front * map_desc->slice_pitch)
2127                     + ((box->top / format->block_height) * map_desc->row_pitch)
2128                     + ((box->left / format->block_width) * format->block_byte_count);
2129         }
2130         else
2131         {
2132             map_desc->data = base_memory
2133                     + (box->front * map_desc->slice_pitch)
2134                     + (box->top * map_desc->row_pitch)
2135                     + (box->left * format->byte_count);
2136         }
2137     }
2138
2139     if (texture->swapchain && texture->swapchain->front_buffer == texture)
2140     {
2141         RECT *r = &texture->swapchain->front_buffer_update;
2142
2143         if (!box)
2144             SetRect(r, 0, 0, resource->width, resource->height);
2145         else
2146             SetRect(r, box->left, box->top, box->right, box->bottom);
2147         TRACE("Mapped front buffer %s.\n", wine_dbgstr_rect(r));
2148     }
2149
2150     ++resource->map_count;
2151     ++sub_resource->map_count;
2152
2153     TRACE("Returning memory %p, row pitch %u, slice pitch %u.\n",
2154             map_desc->data, map_desc->row_pitch, map_desc->slice_pitch);
2155
2156     return WINED3D_OK;
2157 }
2158
2159 static HRESULT texture_resource_sub_resource_unmap(struct wined3d_resource *resource, unsigned int sub_resource_idx)
2160 {
2161     struct wined3d_texture_sub_resource *sub_resource;
2162     struct wined3d_device *device = resource->device;
2163     struct wined3d_context *context = NULL;
2164     struct wined3d_texture *texture;
2165     struct wined3d_bo_address data;
2166
2167     TRACE("resource %p, sub_resource_idx %u.\n", resource, sub_resource_idx);
2168
2169     texture = texture_from_resource(resource);
2170     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
2171         return E_INVALIDARG;
2172
2173     if (!sub_resource->map_count)
2174     {
2175         WARN("Trying to unmap unmapped sub-resource.\n");
2176         if (texture->flags & WINED3D_TEXTURE_DC_IN_USE)
2177             return WINED3D_OK;
2178         return WINEDDERR_NOTLOCKED;
2179     }
2180
2181     if (device->d3d_initialized)
2182         context = context_acquire(device, NULL, 0);
2183
2184     wined3d_texture_get_memory(texture, sub_resource_idx, &data, texture->resource.map_binding);
2185     context_unmap_bo_address(context, &data, GL_PIXEL_UNPACK_BUFFER);
2186
2187     if (context)
2188         context_release(context);
2189
2190     if (texture->swapchain && texture->swapchain->front_buffer == texture)
2191     {
2192         if (!(sub_resource->locations & (WINED3D_LOCATION_DRAWABLE | WINED3D_LOCATION_TEXTURE_RGB)))
2193             texture->swapchain->swapchain_ops->swapchain_frontbuffer_updated(texture->swapchain);
2194     }
2195
2196     --sub_resource->map_count;
2197     if (!--resource->map_count && texture->update_map_binding)
2198         wined3d_texture_update_map_binding(texture);
2199
2200     return WINED3D_OK;
2201 }
2202
2203 static const struct wined3d_resource_ops texture_resource_ops =
2204 {
2205     texture_resource_incref,
2206     texture_resource_decref,
2207     texture_resource_preload,
2208     wined3d_texture_unload,
2209     texture_resource_sub_resource_map,
2210     texture_resource_sub_resource_unmap,
2211 };
2212
2213 static HRESULT wined3d_texture_init(struct wined3d_texture *texture, const struct wined3d_resource_desc *desc,
2214         unsigned int layer_count, unsigned int level_count, DWORD flags, struct wined3d_device *device,
2215         void *parent, const struct wined3d_parent_ops *parent_ops, const struct wined3d_texture_ops *texture_ops)
2216 {
2217     struct wined3d_device_parent *device_parent = device->device_parent;
2218     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
2219     unsigned int sub_count, i, j, size, offset = 0;
2220     unsigned int pow2_width, pow2_height;
2221     const struct wined3d_format *format;
2222     HRESULT hr;
2223
2224     TRACE("texture %p, resource_type %s, format %s, multisample_type %#x, multisample_quality %#x, "
2225             "usage %s, access %s, width %u, height %u, depth %u, layer_count %u, level_count %u, "
2226             "flags %#x, device %p, parent %p, parent_ops %p, texture_ops %p.\n",
2227             texture, debug_d3dresourcetype(desc->resource_type), debug_d3dformat(desc->format),
2228             desc->multisample_type, desc->multisample_quality, debug_d3dusage(desc->usage),
2229             wined3d_debug_resource_access(desc->access), desc->width, desc->height, desc->depth,
2230             layer_count, level_count, flags, device, parent, parent_ops, texture_ops);
2231
2232     if (!desc->width || !desc->height || !desc->depth)
2233         return WINED3DERR_INVALIDCALL;
2234
2235     if (desc->resource_type == WINED3D_RTYPE_TEXTURE_3D)
2236     {
2237         if (layer_count != 1)
2238         {
2239             ERR("Invalid layer count for volume texture.\n");
2240             return E_INVALIDARG;
2241         }
2242
2243         if (!gl_info->supported[EXT_TEXTURE3D])
2244         {
2245             WARN("OpenGL implementation does not support 3D textures.\n");
2246             return WINED3DERR_INVALIDCALL;
2247         }
2248     }
2249
2250     if (!(desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP) && layer_count > 1
2251             && !gl_info->supported[EXT_TEXTURE_ARRAY])
2252     {
2253         WARN("OpenGL implementation does not support array textures.\n");
2254         return WINED3DERR_INVALIDCALL;
2255     }
2256
2257     /* TODO: It should only be possible to create textures for formats
2258      * that are reported as supported. */
2259     if (WINED3DFMT_UNKNOWN >= desc->format)
2260     {
2261         WARN("Texture cannot be created with a format of WINED3DFMT_UNKNOWN.\n");
2262         return WINED3DERR_INVALIDCALL;
2263     }
2264
2265     if (desc->usage & WINED3DUSAGE_DYNAMIC && (wined3d_resource_access_is_managed(desc->access)
2266             || desc->usage & WINED3DUSAGE_SCRATCH))
2267     {
2268         WARN("Attempted to create a dynamic texture with access %s and usage %s.\n",
2269                 wined3d_debug_resource_access(desc->access), debug_d3dusage(desc->usage));
2270         return WINED3DERR_INVALIDCALL;
2271     }
2272
2273     if (!(desc->usage & (WINED3DUSAGE_DYNAMIC | WINED3DUSAGE_RENDERTARGET | WINED3DUSAGE_DEPTHSTENCIL))
2274             && (flags & WINED3D_TEXTURE_CREATE_MAPPABLE))
2275         WARN("Creating a mappable texture that doesn't specify dynamic usage.\n");
2276     if (desc->usage & WINED3DUSAGE_RENDERTARGET && desc->access & WINED3D_RESOURCE_ACCESS_CPU)
2277         FIXME("Trying to create a CPU accessible render target.\n");
2278
2279     pow2_width = desc->width;
2280     pow2_height = desc->height;
2281     if (((desc->width & (desc->width - 1)) || (desc->height & (desc->height - 1)) || (desc->depth & (desc->depth - 1)))
2282             && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
2283     {
2284         /* level_count == 0 returns an error as well. */
2285         if (level_count != 1 || layer_count != 1 || desc->resource_type == WINED3D_RTYPE_TEXTURE_3D)
2286         {
2287             if (!(desc->usage & WINED3DUSAGE_SCRATCH))
2288             {
2289                 WARN("Attempted to create a mipmapped/cube/array/volume NPOT "
2290                         "texture without unconditional NPOT support.\n");
2291                 return WINED3DERR_INVALIDCALL;
2292             }
2293
2294             WARN("Creating a scratch mipmapped/cube/array NPOT texture despite lack of HW support.\n");
2295         }
2296         texture->flags |= WINED3D_TEXTURE_COND_NP2;
2297
2298         if (desc->resource_type != WINED3D_RTYPE_TEXTURE_3D && !gl_info->supported[ARB_TEXTURE_RECTANGLE]
2299                 && !gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT])
2300         {
2301             const struct wined3d_format *format = wined3d_get_format(gl_info, desc->format, desc->usage);
2302
2303             /* TODO: Add support for non-power-of-two compressed textures. */
2304             if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D]
2305                     & (WINED3DFMT_FLAG_COMPRESSED | WINED3DFMT_FLAG_HEIGHT_SCALE))
2306             {
2307                 FIXME("Compressed or height scaled non-power-of-two (%ux%u) textures are not supported.\n",
2308                         desc->width, desc->height);
2309                 return WINED3DERR_NOTAVAILABLE;
2310             }
2311
2312             /* Find the nearest pow2 match. */
2313             pow2_width = pow2_height = 1;
2314             while (pow2_width < desc->width)
2315                 pow2_width <<= 1;
2316             while (pow2_height < desc->height)
2317                 pow2_height <<= 1;
2318             texture->flags |= WINED3D_TEXTURE_COND_NP2_EMULATED;
2319         }
2320     }
2321     texture->pow2_width = pow2_width;
2322     texture->pow2_height = pow2_height;
2323
2324     if ((pow2_width > gl_info->limits.texture_size || pow2_height > gl_info->limits.texture_size)
2325             && (desc->usage & WINED3DUSAGE_TEXTURE))
2326     {
2327         /* One of four options:
2328          * 1: Do the same as we do with NPOT and scale the texture. (Any
2329          *    texture ops would require the texture to be scaled which is
2330          *    potentially slow.)
2331          * 2: Set the texture to the maximum size (bad idea).
2332          * 3: WARN and return WINED3DERR_NOTAVAILABLE.
2333          * 4: Create the surface, but allow it to be used only for DirectDraw
2334          *    Blts. Some apps (e.g. Swat 3) create textures with a height of
2335          *    16 and a width > 3000 and blt 16x16 letter areas from them to
2336          *    the render target. */
2337         if (desc->access & WINED3D_RESOURCE_ACCESS_GPU)
2338         {
2339             WARN("Dimensions (%ux%u) exceed the maximum texture size.\n", pow2_width, pow2_height);
2340             return WINED3DERR_NOTAVAILABLE;
2341         }
2342
2343         /* We should never use this surface in combination with OpenGL. */
2344         TRACE("Creating an oversized (%ux%u) surface.\n", pow2_width, pow2_height);
2345     }
2346
2347     format = wined3d_get_format(&device->adapter->gl_info, desc->format, desc->usage);
2348     for (i = 0; i < layer_count; ++i)
2349     {
2350         for (j = 0; j < level_count; ++j)
2351         {
2352             unsigned int idx = i * level_count + j;
2353
2354             size = wined3d_format_calculate_size(format, device->surface_alignment,
2355                     max(1, desc->width >> j), max(1, desc->height >> j), max(1, desc->depth >> j));
2356             texture->sub_resources[idx].offset = offset;
2357             texture->sub_resources[idx].size = size;
2358             offset += size;
2359         }
2360         offset = (offset + (RESOURCE_ALIGNMENT - 1)) & ~(RESOURCE_ALIGNMENT - 1);
2361     }
2362
2363     if (!offset)
2364         return WINED3DERR_INVALIDCALL;
2365
2366     if (FAILED(hr = resource_init(&texture->resource, device, desc->resource_type, format,
2367             desc->multisample_type, desc->multisample_quality, desc->usage, desc->access,
2368             desc->width, desc->height, desc->depth, offset, parent, parent_ops, &texture_resource_ops)))
2369     {
2370         static unsigned int once;
2371
2372         /* DXTn 3D textures are not supported. Do not write the ERR for them. */
2373         if ((desc->format == WINED3DFMT_DXT1 || desc->format == WINED3DFMT_DXT2 || desc->format == WINED3DFMT_DXT3
2374                 || desc->format == WINED3DFMT_DXT4 || desc->format == WINED3DFMT_DXT5)
2375                 && !(format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_TEXTURE)
2376                 && desc->resource_type != WINED3D_RTYPE_TEXTURE_3D && !once++)
2377             ERR_(winediag)("The application tried to create a DXTn texture, but the driver does not support them.\n");
2378
2379         WARN("Failed to initialize resource, returning %#x\n", hr);
2380         return hr;
2381     }
2382     wined3d_resource_update_draw_binding(&texture->resource);
2383     if ((flags & WINED3D_TEXTURE_CREATE_MAPPABLE) || desc->format == WINED3DFMT_D16_LOCKABLE)
2384         texture->resource.access |= WINED3D_RESOURCE_ACCESS_MAP_R | WINED3D_RESOURCE_ACCESS_MAP_W;
2385
2386     texture->texture_ops = texture_ops;
2387
2388     texture->layer_count = layer_count;
2389     texture->level_count = level_count;
2390     texture->lod = 0;
2391     texture->flags |= WINED3D_TEXTURE_POW2_MAT_IDENT | WINED3D_TEXTURE_NORMALIZED_COORDS;
2392     if (flags & WINED3D_TEXTURE_CREATE_GET_DC_LENIENT)
2393         texture->flags |= WINED3D_TEXTURE_PIN_SYSMEM | WINED3D_TEXTURE_GET_DC_LENIENT;
2394     if (flags & (WINED3D_TEXTURE_CREATE_GET_DC | WINED3D_TEXTURE_CREATE_GET_DC_LENIENT))
2395         texture->flags |= WINED3D_TEXTURE_GET_DC;
2396     if (flags & WINED3D_TEXTURE_CREATE_DISCARD)
2397         texture->flags |= WINED3D_TEXTURE_DISCARD;
2398     if (flags & WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS)
2399     {
2400         if (!(texture->resource.format_flags & WINED3DFMT_FLAG_GEN_MIPMAP))
2401             WARN("Format doesn't support mipmaps generation, "
2402                     "ignoring WINED3D_TEXTURE_CREATE_GENERATE_MIPMAPS flag.\n");
2403         else
2404             texture->flags |= WINED3D_TEXTURE_GENERATE_MIPMAPS;
2405     }
2406
2407     list_init(&texture->renderbuffers);
2408
2409     /* Precalculated scaling for 'faked' non power of two texture coords. */
2410     if (texture->resource.gl_type == WINED3D_GL_RES_TYPE_TEX_RECT)
2411     {
2412         texture->pow2_matrix[0] = (float)desc->width;
2413         texture->pow2_matrix[5] = (float)desc->height;
2414         texture->flags &= ~(WINED3D_TEXTURE_POW2_MAT_IDENT | WINED3D_TEXTURE_NORMALIZED_COORDS);
2415         texture->target = GL_TEXTURE_RECTANGLE_ARB;
2416     }
2417     else
2418     {
2419         if (texture->flags & WINED3D_TEXTURE_COND_NP2_EMULATED)
2420         {
2421             texture->pow2_matrix[0] = (((float)desc->width) / ((float)pow2_width));
2422             texture->pow2_matrix[5] = (((float)desc->height) / ((float)pow2_height));
2423             texture->flags &= ~WINED3D_TEXTURE_POW2_MAT_IDENT;
2424         }
2425         else
2426         {
2427             texture->pow2_matrix[0] = 1.0f;
2428             texture->pow2_matrix[5] = 1.0f;
2429         }
2430         if (desc->resource_type == WINED3D_RTYPE_TEXTURE_3D)
2431         {
2432             texture->target = GL_TEXTURE_3D;
2433         }
2434         else if (desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP)
2435         {
2436             texture->target = GL_TEXTURE_CUBE_MAP_ARB;
2437         }
2438         else if (desc->multisample_type && gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
2439         {
2440             if (layer_count > 1)
2441                 texture->target = GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
2442             else
2443                 texture->target = GL_TEXTURE_2D_MULTISAMPLE;
2444         }
2445         else
2446         {
2447             if (layer_count > 1)
2448                 texture->target = GL_TEXTURE_2D_ARRAY;
2449             else
2450                 texture->target = GL_TEXTURE_2D;
2451         }
2452     }
2453     texture->pow2_matrix[10] = 1.0f;
2454     texture->pow2_matrix[15] = 1.0f;
2455     TRACE("x scale %.8e, y scale %.8e.\n", texture->pow2_matrix[0], texture->pow2_matrix[5]);
2456
2457     if (wined3d_texture_use_pbo(texture, gl_info))
2458     {
2459         if (desc->resource_type == WINED3D_RTYPE_TEXTURE_3D
2460                 || (texture->resource.usage & WINED3DUSAGE_DEPTHSTENCIL))
2461             wined3d_resource_free_sysmem(&texture->resource);
2462         texture->resource.map_binding = WINED3D_LOCATION_BUFFER;
2463     }
2464
2465     sub_count = level_count * layer_count;
2466     if (sub_count / layer_count != level_count)
2467     {
2468         wined3d_texture_cleanup_sync(texture);
2469         return E_OUTOFMEMORY;
2470     }
2471
2472     if (desc->usage & WINED3DUSAGE_OVERLAY)
2473     {
2474         if (!(texture->overlay_info = heap_calloc(sub_count, sizeof(*texture->overlay_info))))
2475         {
2476             wined3d_texture_cleanup_sync(texture);
2477             return E_OUTOFMEMORY;
2478         }
2479
2480         for (i = 0; i < sub_count; ++i)
2481         {
2482             list_init(&texture->overlay_info[i].entry);
2483             list_init(&texture->overlay_info[i].overlays);
2484         }
2485     }
2486
2487     /* Generate all sub-resources. */
2488     for (i = 0; i < sub_count; ++i)
2489     {
2490         struct wined3d_texture_sub_resource *sub_resource;
2491
2492         sub_resource = &texture->sub_resources[i];
2493         sub_resource->locations = WINED3D_LOCATION_DISCARDED;
2494         if (desc->resource_type != WINED3D_RTYPE_TEXTURE_3D
2495                 && !(texture->resource.usage & WINED3DUSAGE_DEPTHSTENCIL))
2496         {
2497             wined3d_texture_validate_location(texture, i, WINED3D_LOCATION_SYSMEM);
2498             wined3d_texture_invalidate_location(texture, i, ~WINED3D_LOCATION_SYSMEM);
2499         }
2500
2501         if (FAILED(hr = device_parent->ops->texture_sub_resource_created(device_parent,
2502                 desc->resource_type, texture, i, &sub_resource->parent, &sub_resource->parent_ops)))
2503         {
2504             WARN("Failed to create sub-resource parent, hr %#x.\n", hr);
2505             sub_resource->parent = NULL;
2506             wined3d_texture_cleanup_sync(texture);
2507             return hr;
2508         }
2509
2510         TRACE("parent %p, parent_ops %p.\n", sub_resource->parent, sub_resource->parent_ops);
2511
2512         TRACE("Created sub-resource %u (level %u, layer %u).\n",
2513                 i, i % texture->level_count, i / texture->level_count);
2514
2515         if ((desc->usage & WINED3DUSAGE_OWNDC) || (device->wined3d->flags & WINED3D_NO3D))
2516         {
2517             struct wined3d_texture_idx texture_idx = {texture, i};
2518
2519             wined3d_cs_init_object(device->cs, wined3d_texture_create_dc, &texture_idx);
2520             device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
2521             if (!texture->dc_info || !texture->dc_info[i].dc)
2522             {
2523                 wined3d_texture_cleanup_sync(texture);
2524                 return WINED3DERR_INVALIDCALL;
2525             }
2526         }
2527     }
2528
2529     return WINED3D_OK;
2530 }
2531
2532 /* This call just uploads data, the caller is responsible for binding the
2533  * correct texture. */
2534 /* Context activation is done by the caller. */
2535 static void texture3d_upload_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
2536         const struct wined3d_context *context, const struct wined3d_format *format, const struct wined3d_box *src_box,
2537         const struct wined3d_const_bo_address *data, unsigned int row_pitch, unsigned int slice_pitch,
2538         unsigned int dst_x, unsigned int dst_y, unsigned int dst_z, BOOL srgb)
2539 {
2540     unsigned int level = sub_resource_idx % texture->level_count;
2541     const struct wined3d_gl_info *gl_info = context->gl_info;
2542     unsigned int dst_row_pitch, dst_slice_pitch;
2543     unsigned int update_w, update_h, update_d;
2544     const BYTE *addr = data->addr;
2545     void *converted_mem = NULL;
2546
2547     TRACE("texture %p, sub_resource_idx %u, context %p, format %s, src_box %s, data {%#x:%p}, "
2548             "row_pitch %#x, slice_pitch %#x, dst_x %u, dst_y %u, dst_z %u, srgb %#x.\n",
2549             texture, sub_resource_idx, context, debug_d3dformat(format->id), debug_box(src_box),
2550             data->buffer_object, data->addr, row_pitch, slice_pitch, dst_x, dst_y, dst_z, srgb);
2551
2552     if (src_box)
2553     {
2554         addr += src_box->front * slice_pitch;
2555         addr += src_box->top * row_pitch;
2556         addr += src_box->left * format->byte_count;
2557
2558         update_w = src_box->right - src_box->left;
2559         update_h = src_box->bottom - src_box->top;
2560         update_d = src_box->back - src_box->front;
2561     }
2562     else
2563     {
2564         update_w = wined3d_texture_get_level_width(texture, level);
2565         update_h = wined3d_texture_get_level_height(texture, level);
2566         update_d = wined3d_texture_get_level_depth(texture, level);
2567     }
2568
2569     if (format->conv_byte_count)
2570     {
2571         if (data->buffer_object)
2572             ERR("Loading a converted texture from a PBO.\n");
2573         if (texture->resource.format_flags & WINED3DFMT_FLAG_BLOCKS)
2574             ERR("Converting a block-based format.\n");
2575
2576         dst_row_pitch = update_w * format->conv_byte_count;
2577         dst_slice_pitch = dst_row_pitch * update_h;
2578
2579         converted_mem = heap_calloc(update_d, dst_slice_pitch);
2580         format->upload(addr, converted_mem, row_pitch, slice_pitch,
2581                 dst_row_pitch, dst_slice_pitch, update_w, update_h, update_d);
2582         addr = converted_mem;
2583     }
2584     else
2585     {
2586         wined3d_texture_get_pitch(texture, sub_resource_idx, &dst_row_pitch, &dst_slice_pitch);
2587         if (row_pitch != dst_row_pitch || slice_pitch != dst_slice_pitch)
2588             FIXME("Ignoring row/slice pitch (%u/%u).\n", row_pitch, slice_pitch);
2589     }
2590
2591     if (data->buffer_object)
2592     {
2593         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, data->buffer_object));
2594         checkGLcall("glBindBuffer");
2595     }
2596
2597     GL_EXTCALL(glTexSubImage3D(GL_TEXTURE_3D, level, dst_x, dst_y, dst_z,
2598             update_w, update_h, update_d, format->glFormat, format->glType, addr));
2599     checkGLcall("glTexSubImage3D");
2600
2601     if (data->buffer_object)
2602     {
2603         GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
2604         checkGLcall("glBindBuffer");
2605     }
2606
2607     heap_free(converted_mem);
2608 }
2609
2610 /* Context activation is done by the caller. */
2611 static void texture3d_download_data(struct wined3d_texture *texture, unsigned int sub_resource_idx,
2612         const struct wined3d_context *context, const struct wined3d_bo_address *data)
2613 {
2614     const struct wined3d_format *format = texture->resource.format;
2615     const struct wined3d_gl_info *gl_info = context->gl_info;
2616
2617     if (format->conv_byte_count)
2618     {
2619         FIXME("Attempting to download a converted volume, format %s.\n",
2620                 debug_d3dformat(format->id));
2621         return;
2622     }
2623
2624     if (data->buffer_object)
2625     {
2626         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, data->buffer_object));
2627         checkGLcall("glBindBuffer");
2628     }
2629
2630     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_3D, sub_resource_idx,
2631             format->glFormat, format->glType, data->addr);
2632     checkGLcall("glGetTexImage");
2633
2634     if (data->buffer_object)
2635     {
2636         GL_EXTCALL(glBindBuffer(GL_PIXEL_PACK_BUFFER, 0));
2637         checkGLcall("glBindBuffer");
2638     }
2639
2640 }
2641
2642 /* Context activation is done by the caller. */
2643 static void texture3d_srgb_transfer(struct wined3d_texture *texture, unsigned int sub_resource_idx,
2644         struct wined3d_context *context, BOOL dest_is_srgb)
2645 {
2646     struct wined3d_texture_sub_resource *sub_resource = &texture->sub_resources[sub_resource_idx];
2647     unsigned int row_pitch, slice_pitch;
2648     struct wined3d_bo_address data;
2649
2650     /* Optimisations are possible, but the effort should be put into either
2651      * implementing EXT_SRGB_DECODE in the driver or finding out why we
2652      * picked the wrong copy for the original upload and fixing that.
2653      *
2654      * Also keep in mind that we want to avoid using resource.heap_memory
2655      * for DEFAULT pool surfaces. */
2656     WARN_(d3d_perf)("Performing slow rgb/srgb volume transfer.\n");
2657     data.buffer_object = 0;
2658     if (!(data.addr = heap_alloc(sub_resource->size)))
2659         return;
2660
2661     wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch);
2662     wined3d_texture_bind_and_dirtify(texture, context, !dest_is_srgb);
2663     texture3d_download_data(texture, sub_resource_idx, context, &data);
2664     wined3d_texture_bind_and_dirtify(texture, context, dest_is_srgb);
2665     texture3d_upload_data(texture, sub_resource_idx, context, texture->resource.format,
2666             NULL, wined3d_const_bo_address(&data), row_pitch, slice_pitch, 0, 0, 0, FALSE);
2667
2668     heap_free(data.addr);
2669 }
2670
2671 /* Context activation is done by the caller. */
2672 static BOOL texture3d_load_location(struct wined3d_texture *texture, unsigned int sub_resource_idx,
2673         struct wined3d_context *context, DWORD location)
2674 {
2675     struct wined3d_texture_sub_resource *sub_resource = &texture->sub_resources[sub_resource_idx];
2676     unsigned int row_pitch, slice_pitch;
2677
2678     if (!wined3d_texture_prepare_location(texture, sub_resource_idx, context, location))
2679         return FALSE;
2680
2681     switch (location)
2682     {
2683         case WINED3D_LOCATION_TEXTURE_RGB:
2684         case WINED3D_LOCATION_TEXTURE_SRGB:
2685             if (sub_resource->locations & WINED3D_LOCATION_SYSMEM)
2686             {
2687                 struct wined3d_const_bo_address data = {0, texture->resource.heap_memory};
2688                 data.addr += sub_resource->offset;
2689                 wined3d_texture_bind_and_dirtify(texture, context,
2690                         location == WINED3D_LOCATION_TEXTURE_SRGB);
2691                 wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch);
2692                 texture3d_upload_data(texture, sub_resource_idx, context, texture->resource.format,
2693                         NULL, &data, row_pitch, slice_pitch, 0, 0, 0, FALSE);
2694             }
2695             else if (sub_resource->locations & WINED3D_LOCATION_BUFFER)
2696             {
2697                 struct wined3d_const_bo_address data = {sub_resource->buffer_object, NULL};
2698                 wined3d_texture_bind_and_dirtify(texture, context,
2699                         location == WINED3D_LOCATION_TEXTURE_SRGB);
2700                 wined3d_texture_get_pitch(texture, sub_resource_idx, &row_pitch, &slice_pitch);
2701                 texture3d_upload_data(texture, sub_resource_idx, context, texture->resource.format,
2702                         NULL, &data, row_pitch, slice_pitch, 0, 0, 0, FALSE);
2703             }
2704             else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
2705             {
2706                 texture3d_srgb_transfer(texture, sub_resource_idx, context, TRUE);
2707             }
2708             else if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_SRGB)
2709             {
2710                 texture3d_srgb_transfer(texture, sub_resource_idx, context, FALSE);
2711             }
2712             else
2713             {
2714                 FIXME("Implement texture loading from %s.\n", wined3d_debug_location(sub_resource->locations));
2715                 return FALSE;
2716             }
2717             break;
2718
2719         case WINED3D_LOCATION_SYSMEM:
2720             if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
2721             {
2722                 struct wined3d_bo_address data = {0, texture->resource.heap_memory};
2723
2724                 data.addr += sub_resource->offset;
2725                 if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
2726                     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
2727                 else
2728                     wined3d_texture_bind_and_dirtify(texture, context, TRUE);
2729
2730                 texture3d_download_data(texture, sub_resource_idx, context, &data);
2731                 ++texture->download_count;
2732             }
2733             else
2734             {
2735                 FIXME("Implement WINED3D_LOCATION_SYSMEM loading from %s.\n",
2736                         wined3d_debug_location(sub_resource->locations));
2737                 return FALSE;
2738             }
2739             break;
2740
2741         case WINED3D_LOCATION_BUFFER:
2742             if (sub_resource->locations & (WINED3D_LOCATION_TEXTURE_RGB | WINED3D_LOCATION_TEXTURE_SRGB))
2743             {
2744                 struct wined3d_bo_address data = {sub_resource->buffer_object, NULL};
2745
2746                 if (sub_resource->locations & WINED3D_LOCATION_TEXTURE_RGB)
2747                     wined3d_texture_bind_and_dirtify(texture, context, FALSE);
2748                 else
2749                     wined3d_texture_bind_and_dirtify(texture, context, TRUE);
2750
2751                 texture3d_download_data(texture, sub_resource_idx, context, &data);
2752             }
2753             else
2754             {
2755                 FIXME("Implement WINED3D_LOCATION_BUFFER loading from %s.\n",
2756                         wined3d_debug_location(sub_resource->locations));
2757                 return FALSE;
2758             }
2759             break;
2760
2761         default:
2762             FIXME("Implement %s loading from %s.\n", wined3d_debug_location(location),
2763                     wined3d_debug_location(sub_resource->locations));
2764             return FALSE;
2765     }
2766
2767     return TRUE;
2768 }
2769
2770 static const struct wined3d_texture_ops texture3d_ops =
2771 {
2772     texture3d_upload_data,
2773     texture3d_load_location,
2774 };
2775
2776 HRESULT CDECL wined3d_texture_blt(struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
2777         const RECT *dst_rect, struct wined3d_texture *src_texture, unsigned int src_sub_resource_idx,
2778         const RECT *src_rect, DWORD flags, const struct wined3d_blt_fx *fx, enum wined3d_texture_filter_type filter)
2779 {
2780     struct wined3d_box src_box = {src_rect->left, src_rect->top, src_rect->right, src_rect->bottom, 0, 1};
2781     struct wined3d_box dst_box = {dst_rect->left, dst_rect->top, dst_rect->right, dst_rect->bottom, 0, 1};
2782     unsigned int dst_format_flags, src_format_flags = 0;
2783     HRESULT hr;
2784
2785     TRACE("dst_texture %p, dst_sub_resource_idx %u, dst_rect %s, src_texture %p, "
2786             "src_sub_resource_idx %u, src_rect %s, flags %#x, fx %p, filter %s.\n",
2787             dst_texture, dst_sub_resource_idx, wine_dbgstr_rect(dst_rect), src_texture,
2788             src_sub_resource_idx, wine_dbgstr_rect(src_rect), flags, fx, debug_d3dtexturefiltertype(filter));
2789
2790     if (dst_sub_resource_idx >= dst_texture->level_count * dst_texture->layer_count
2791             || dst_texture->resource.type != WINED3D_RTYPE_TEXTURE_2D)
2792         return WINED3DERR_INVALIDCALL;
2793
2794     if (src_sub_resource_idx >= src_texture->level_count * src_texture->layer_count
2795             || src_texture->resource.type != WINED3D_RTYPE_TEXTURE_2D)
2796         return WINED3DERR_INVALIDCALL;
2797
2798     dst_format_flags = dst_texture->resource.format_flags;
2799     if (FAILED(hr = wined3d_texture_check_box_dimensions(dst_texture,
2800             dst_sub_resource_idx % dst_texture->level_count, &dst_box)))
2801         return hr;
2802
2803     src_format_flags = src_texture->resource.format_flags;
2804     if (FAILED(hr = wined3d_texture_check_box_dimensions(src_texture,
2805             src_sub_resource_idx % src_texture->level_count, &src_box)))
2806         return hr;
2807
2808     if (dst_texture->sub_resources[dst_sub_resource_idx].map_count
2809             || src_texture->sub_resources[src_sub_resource_idx].map_count)
2810     {
2811         WARN("Sub-resource is busy, returning WINEDDERR_SURFACEBUSY.\n");
2812         return WINEDDERR_SURFACEBUSY;
2813     }
2814
2815     if ((src_format_flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))
2816             != (dst_format_flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2817     {
2818         WARN("Rejecting depth/stencil blit between incompatible formats.\n");
2819         return WINED3DERR_INVALIDCALL;
2820     }
2821
2822     wined3d_cs_emit_blt_sub_resource(dst_texture->resource.device->cs, &dst_texture->resource, dst_sub_resource_idx,
2823             &dst_box, &src_texture->resource, src_sub_resource_idx, &src_box, flags, fx, filter);
2824
2825     return WINED3D_OK;
2826 }
2827
2828 HRESULT CDECL wined3d_texture_get_overlay_position(const struct wined3d_texture *texture,
2829         unsigned int sub_resource_idx, LONG *x, LONG *y)
2830 {
2831     struct wined3d_overlay_info *overlay;
2832
2833     TRACE("texture %p, sub_resource_idx %u, x %p, y %p.\n", texture, sub_resource_idx, x, y);
2834
2835     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY)
2836             || sub_resource_idx >= texture->level_count * texture->layer_count)
2837     {
2838         WARN("Invalid sub-resource specified.\n");
2839         return WINEDDERR_NOTAOVERLAYSURFACE;
2840     }
2841
2842     overlay = &texture->overlay_info[sub_resource_idx];
2843     if (!overlay->dst_texture)
2844     {
2845         TRACE("Overlay not visible.\n");
2846         *x = 0;
2847         *y = 0;
2848         return WINEDDERR_OVERLAYNOTVISIBLE;
2849     }
2850
2851     *x = overlay->dst_rect.left;
2852     *y = overlay->dst_rect.top;
2853
2854     TRACE("Returning position %d, %d.\n", *x, *y);
2855
2856     return WINED3D_OK;
2857 }
2858
2859 HRESULT CDECL wined3d_texture_set_overlay_position(struct wined3d_texture *texture,
2860         unsigned int sub_resource_idx, LONG x, LONG y)
2861 {
2862     struct wined3d_overlay_info *overlay;
2863     LONG w, h;
2864
2865     TRACE("texture %p, sub_resource_idx %u, x %d, y %d.\n", texture, sub_resource_idx, x, y);
2866
2867     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY)
2868             || sub_resource_idx >= texture->level_count * texture->layer_count)
2869     {
2870         WARN("Invalid sub-resource specified.\n");
2871         return WINEDDERR_NOTAOVERLAYSURFACE;
2872     }
2873
2874     overlay = &texture->overlay_info[sub_resource_idx];
2875     w = overlay->dst_rect.right - overlay->dst_rect.left;
2876     h = overlay->dst_rect.bottom - overlay->dst_rect.top;
2877     SetRect(&overlay->dst_rect, x, y, x + w, y + h);
2878
2879     return WINED3D_OK;
2880 }
2881
2882 HRESULT CDECL wined3d_texture_update_overlay(struct wined3d_texture *texture, unsigned int sub_resource_idx,
2883         const RECT *src_rect, struct wined3d_texture *dst_texture, unsigned int dst_sub_resource_idx,
2884         const RECT *dst_rect, DWORD flags)
2885 {
2886     struct wined3d_overlay_info *overlay;
2887     unsigned int level, dst_level;
2888
2889     TRACE("texture %p, sub_resource_idx %u, src_rect %s, dst_texture %p, "
2890             "dst_sub_resource_idx %u, dst_rect %s, flags %#x.\n",
2891             texture, sub_resource_idx, wine_dbgstr_rect(src_rect), dst_texture,
2892             dst_sub_resource_idx, wine_dbgstr_rect(dst_rect), flags);
2893
2894     if (!(texture->resource.usage & WINED3DUSAGE_OVERLAY) || texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
2895             || sub_resource_idx >= texture->level_count * texture->layer_count)
2896     {
2897         WARN("Invalid sub-resource specified.\n");
2898         return WINEDDERR_NOTAOVERLAYSURFACE;
2899     }
2900
2901     if (!dst_texture || dst_texture->resource.type != WINED3D_RTYPE_TEXTURE_2D
2902             || dst_sub_resource_idx >= dst_texture->level_count * dst_texture->layer_count)
2903     {
2904         WARN("Invalid destination sub-resource specified.\n");
2905         return WINED3DERR_INVALIDCALL;
2906     }
2907
2908     overlay = &texture->overlay_info[sub_resource_idx];
2909
2910     level = sub_resource_idx % texture->level_count;
2911     if (src_rect)
2912         overlay->src_rect = *src_rect;
2913     else
2914         SetRect(&overlay->src_rect, 0, 0,
2915                 wined3d_texture_get_level_width(texture, level),
2916                 wined3d_texture_get_level_height(texture, level));
2917
2918     dst_level = dst_sub_resource_idx % dst_texture->level_count;
2919     if (dst_rect)
2920         overlay->dst_rect = *dst_rect;
2921     else
2922         SetRect(&overlay->dst_rect, 0, 0,
2923                 wined3d_texture_get_level_width(dst_texture, dst_level),
2924                 wined3d_texture_get_level_height(dst_texture, dst_level));
2925
2926     if (overlay->dst_texture && (overlay->dst_texture != dst_texture
2927             || overlay->dst_sub_resource_idx != dst_sub_resource_idx || flags & WINEDDOVER_HIDE))
2928     {
2929         overlay->dst_texture = NULL;
2930         list_remove(&overlay->entry);
2931     }
2932
2933     if (flags & WINEDDOVER_SHOW)
2934     {
2935         if (overlay->dst_texture != dst_texture || overlay->dst_sub_resource_idx != dst_sub_resource_idx)
2936         {
2937             overlay->dst_texture = dst_texture;
2938             overlay->dst_sub_resource_idx = dst_sub_resource_idx;
2939             list_add_tail(&texture->overlay_info[dst_sub_resource_idx].overlays, &overlay->entry);
2940         }
2941     }
2942     else if (flags & WINEDDOVER_HIDE)
2943     {
2944         /* Tests show that the rectangles are erased on hide. */
2945         SetRectEmpty(&overlay->src_rect);
2946         SetRectEmpty(&overlay->dst_rect);
2947         overlay->dst_texture = NULL;
2948     }
2949
2950     return WINED3D_OK;
2951 }
2952
2953 void * CDECL wined3d_texture_get_sub_resource_parent(struct wined3d_texture *texture, unsigned int sub_resource_idx)
2954 {
2955     unsigned int sub_count = texture->level_count * texture->layer_count;
2956
2957     TRACE("texture %p, sub_resource_idx %u.\n", texture, sub_resource_idx);
2958
2959     if (sub_resource_idx >= sub_count)
2960     {
2961         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
2962         return NULL;
2963     }
2964
2965     return texture->sub_resources[sub_resource_idx].parent;
2966 }
2967
2968 void CDECL wined3d_texture_set_sub_resource_parent(struct wined3d_texture *texture,
2969         unsigned int sub_resource_idx, void *parent)
2970 {
2971     unsigned int sub_count = texture->level_count * texture->layer_count;
2972
2973     TRACE("texture %p, sub_resource_idx %u, parent %p.\n", texture, sub_resource_idx, parent);
2974
2975     if (sub_resource_idx >= sub_count)
2976     {
2977         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
2978         return;
2979     }
2980
2981     texture->sub_resources[sub_resource_idx].parent = parent;
2982 }
2983
2984 HRESULT CDECL wined3d_texture_get_sub_resource_desc(const struct wined3d_texture *texture,
2985         unsigned int sub_resource_idx, struct wined3d_sub_resource_desc *desc)
2986 {
2987     unsigned int sub_count = texture->level_count * texture->layer_count;
2988     const struct wined3d_resource *resource;
2989     unsigned int level_idx;
2990
2991     TRACE("texture %p, sub_resource_idx %u, desc %p.\n", texture, sub_resource_idx, desc);
2992
2993     if (sub_resource_idx >= sub_count)
2994     {
2995         WARN("sub_resource_idx %u >= sub_count %u.\n", sub_resource_idx, sub_count);
2996         return WINED3DERR_INVALIDCALL;
2997     }
2998
2999     resource = &texture->resource;
3000     desc->format = resource->format->id;
3001     desc->multisample_type = resource->multisample_type;
3002     desc->multisample_quality = resource->multisample_quality;
3003     desc->usage = resource->usage;
3004     desc->access = resource->access;
3005
3006     level_idx = sub_resource_idx % texture->level_count;
3007     desc->width = wined3d_texture_get_level_width(texture, level_idx);
3008     desc->height = wined3d_texture_get_level_height(texture, level_idx);
3009     desc->depth = wined3d_texture_get_level_depth(texture, level_idx);
3010     desc->size = texture->sub_resources[sub_resource_idx].size;
3011
3012     return WINED3D_OK;
3013 }
3014
3015 HRESULT CDECL wined3d_texture_create(struct wined3d_device *device, const struct wined3d_resource_desc *desc,
3016         UINT layer_count, UINT level_count, DWORD flags, const struct wined3d_sub_resource_data *data,
3017         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
3018 {
3019     struct wined3d_texture *object;
3020     HRESULT hr;
3021
3022     TRACE("device %p, desc %p, layer_count %u, level_count %u, flags %#x, data %p, "
3023             "parent %p, parent_ops %p, texture %p.\n",
3024             device, desc, layer_count, level_count, flags, data, parent, parent_ops, texture);
3025
3026     if (!layer_count)
3027     {
3028         WARN("Invalid layer count.\n");
3029         return E_INVALIDARG;
3030     }
3031     if ((desc->usage & WINED3DUSAGE_LEGACY_CUBEMAP) && layer_count != 6)
3032     {
3033         ERR("Invalid layer count %u for legacy cubemap.\n", layer_count);
3034         layer_count = 6;
3035     }
3036
3037     if (!level_count)
3038     {
3039         WARN("Invalid level count.\n");
3040         return WINED3DERR_INVALIDCALL;
3041     }
3042
3043     if (desc->multisample_type != WINED3D_MULTISAMPLE_NONE)
3044     {
3045         const struct wined3d_format *format = wined3d_get_format(&device->adapter->gl_info,
3046                 desc->format, desc->usage);
3047
3048         if (desc->multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE
3049                 && desc->multisample_quality >= wined3d_popcount(format->multisample_types))
3050         {
3051             WARN("Unsupported quality level %u requested for WINED3D_MULTISAMPLE_NON_MASKABLE.\n",
3052                     desc->multisample_quality);
3053             return WINED3DERR_NOTAVAILABLE;
3054         }
3055         if (desc->multisample_type != WINED3D_MULTISAMPLE_NON_MASKABLE
3056                 && (!(format->multisample_types & 1u << (desc->multisample_type - 1))
3057                 || desc->multisample_quality))
3058         {
3059             WARN("Unsupported multisample type %u quality %u requested.\n", desc->multisample_type,
3060                     desc->multisample_quality);
3061             return WINED3DERR_NOTAVAILABLE;
3062         }
3063     }
3064
3065     if (!(object = heap_alloc_zero(FIELD_OFFSET(struct wined3d_texture,
3066             sub_resources[level_count * layer_count]))))
3067         return E_OUTOFMEMORY;
3068
3069     switch (desc->resource_type)
3070     {
3071         case WINED3D_RTYPE_TEXTURE_2D:
3072             hr = wined3d_texture_init(object, desc, layer_count, level_count,
3073                     flags, device, parent, parent_ops, &texture2d_ops);
3074             break;
3075
3076         case WINED3D_RTYPE_TEXTURE_3D:
3077             hr = wined3d_texture_init(object, desc, layer_count, level_count,
3078                     flags, device, parent, parent_ops, &texture3d_ops);
3079             break;
3080
3081         default:
3082             ERR("Invalid resource type %s.\n", debug_d3dresourcetype(desc->resource_type));
3083             hr = WINED3DERR_INVALIDCALL;
3084             break;
3085     }
3086
3087     if (FAILED(hr))
3088     {
3089         WARN("Failed to initialize texture, returning %#x.\n", hr);
3090         heap_free(object);
3091         return hr;
3092     }
3093
3094     /* FIXME: We'd like to avoid ever allocating system memory for the texture
3095      * in this case. */
3096     if (data)
3097     {
3098         unsigned int sub_count = level_count * layer_count;
3099         unsigned int i;
3100
3101         for (i = 0; i < sub_count; ++i)
3102         {
3103             if (!data[i].data)
3104             {
3105                 WARN("Invalid sub-resource data specified for sub-resource %u.\n", i);
3106                 wined3d_texture_cleanup_sync(object);
3107                 heap_free(object);
3108                 return E_INVALIDARG;
3109             }
3110         }
3111
3112         for (i = 0; i < sub_count; ++i)
3113         {
3114             wined3d_device_update_sub_resource(device, &object->resource,
3115                     i, NULL, data[i].data, data[i].row_pitch, data[i].slice_pitch);
3116         }
3117     }
3118
3119     TRACE("Created texture %p.\n", object);
3120     *texture = object;
3121
3122     return WINED3D_OK;
3123 }
3124
3125 HRESULT CDECL wined3d_texture_get_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC *dc)
3126 {
3127     struct wined3d_device *device = texture->resource.device;
3128     struct wined3d_texture_sub_resource *sub_resource;
3129     struct wined3d_dc_info *dc_info;
3130
3131     TRACE("texture %p, sub_resource_idx %u, dc %p.\n", texture, sub_resource_idx, dc);
3132
3133     if (!(texture->flags & WINED3D_TEXTURE_GET_DC))
3134     {
3135         WARN("Texture does not support GetDC\n");
3136         /* Don't touch the DC */
3137         return WINED3DERR_INVALIDCALL;
3138     }
3139
3140     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
3141         return WINED3DERR_INVALIDCALL;
3142
3143     if (texture->resource.type != WINED3D_RTYPE_TEXTURE_2D)
3144     {
3145         WARN("Not supported on %s resources.\n", debug_d3dresourcetype(texture->resource.type));
3146         return WINED3DERR_INVALIDCALL;
3147     }
3148
3149     if (texture->resource.map_count && !(texture->flags & WINED3D_TEXTURE_GET_DC_LENIENT))
3150         return WINED3DERR_INVALIDCALL;
3151
3152     if (!(dc_info = texture->dc_info) || !dc_info[sub_resource_idx].dc)
3153     {
3154         struct wined3d_texture_idx texture_idx = {texture, sub_resource_idx};
3155
3156         wined3d_cs_init_object(device->cs, wined3d_texture_create_dc, &texture_idx);
3157         device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
3158         if (!(dc_info = texture->dc_info) || !dc_info[sub_resource_idx].dc)
3159             return WINED3DERR_INVALIDCALL;
3160     }
3161
3162     if (!(texture->flags & WINED3D_TEXTURE_GET_DC_LENIENT))
3163         texture->flags |= WINED3D_TEXTURE_DC_IN_USE;
3164     ++texture->resource.map_count;
3165     ++sub_resource->map_count;
3166
3167     *dc = dc_info[sub_resource_idx].dc;
3168     TRACE("Returning dc %p.\n", *dc);
3169
3170     return WINED3D_OK;
3171 }
3172
3173 HRESULT CDECL wined3d_texture_release_dc(struct wined3d_texture *texture, unsigned int sub_resource_idx, HDC dc)
3174 {
3175     struct wined3d_device *device = texture->resource.device;
3176     struct wined3d_texture_sub_resource *sub_resource;
3177     struct wined3d_dc_info *dc_info;
3178
3179     TRACE("texture %p, sub_resource_idx %u, dc %p.\n", texture, sub_resource_idx, dc);
3180
3181     if (!(sub_resource = wined3d_texture_get_sub_resource(texture, sub_resource_idx)))
3182         return WINED3DERR_INVALIDCALL;
3183
3184     if (texture->resource.type != WINED3D_RTYPE_TEXTURE_2D)
3185     {
3186         WARN("Not supported on %s resources.\n", debug_d3dresourcetype(texture->resource.type));
3187         return WINED3DERR_INVALIDCALL;
3188     }
3189
3190     if (!(texture->flags & (WINED3D_TEXTURE_GET_DC_LENIENT | WINED3D_TEXTURE_DC_IN_USE)))
3191         return WINED3DERR_INVALIDCALL;
3192
3193     if (!(dc_info = texture->dc_info) || dc_info[sub_resource_idx].dc != dc)
3194     {
3195         WARN("Application tries to release invalid DC %p, sub-resource DC is %p.\n",
3196                 dc, dc_info ? dc_info[sub_resource_idx].dc : NULL);
3197         return WINED3DERR_INVALIDCALL;
3198     }
3199
3200     if (!(texture->resource.usage & WINED3DUSAGE_OWNDC) && !(device->wined3d->flags & WINED3D_NO3D))
3201     {
3202         struct wined3d_texture_idx texture_idx = {texture, sub_resource_idx};
3203
3204         wined3d_cs_destroy_object(device->cs, wined3d_texture_destroy_dc, &texture_idx);
3205         device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
3206     }
3207
3208     --sub_resource->map_count;
3209     if (!--texture->resource.map_count && texture->update_map_binding)
3210         wined3d_texture_update_map_binding(texture);
3211     if (!(texture->flags & WINED3D_TEXTURE_GET_DC_LENIENT))
3212         texture->flags &= ~WINED3D_TEXTURE_DC_IN_USE;
3213
3214     return WINED3D_OK;
3215 }