dlls/windowscodecs/ddsformat.c

   1 /*
   2  * Copyright 2020 Ziqing Hui
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <stdarg.h>
  23
  24 #define COBJMACROS
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29
  30 #include "wincodecs_private.h"
  31
  32 #include "wine/debug.h"
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  35
  36 #define DDS_MAGIC 0x20534444
  37 #ifndef MAKEFOURCC
  38 #define MAKEFOURCC(ch0, ch1, ch2, ch3)  \
  39     ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) |  \
  40     ((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
  41 #endif
  42
  43 #define DDPF_ALPHAPIXELS     0x00000001
  44 #define DDPF_ALPHA           0x00000002
  45 #define DDPF_FOURCC          0x00000004
  46 #define DDPF_PALETTEINDEXED8 0x00000020
  47 #define DDPF_RGB             0x00000040
  48 #define DDPF_LUMINANCE       0x00020000
  49 #define DDPF_BUMPDUDV        0x00080000
  50
  51 #define DDSCAPS2_CUBEMAP 0x00000200
  52 #define DDSCAPS2_VOLUME  0x00200000
  53
  54 #define DDS_DIMENSION_TEXTURE1D 2
  55 #define DDS_DIMENSION_TEXTURE2D 3
  56 #define DDS_DIMENSION_TEXTURE3D 4
  57
  58 #define DDS_RESOURCE_MISC_TEXTURECUBE 0x00000004
  59
  60 #define DDS_BLOCK_WIDTH  4
  61 #define DDS_BLOCK_HEIGHT 4
  62
  63 typedef struct {
  64     DWORD size;
  65     DWORD flags;
  66     DWORD fourCC;
  67     DWORD rgbBitCount;
  68     DWORD rBitMask;
  69     DWORD gBitMask;
  70     DWORD bBitMask;
  71     DWORD aBitMask;
  72 } DDS_PIXELFORMAT;
  73
  74 typedef struct {
  75     DWORD size;
  76     DWORD flags;
  77     DWORD height;
  78     DWORD width;
  79     DWORD pitchOrLinearSize;
  80     DWORD depth;
  81     DWORD mipMapCount;
  82     DWORD reserved1[11];
  83     DDS_PIXELFORMAT ddspf;
  84     DWORD caps;
  85     DWORD caps2;
  86     DWORD caps3;
  87     DWORD caps4;
  88     DWORD reserved2;
  89 } DDS_HEADER;
  90
  91 typedef struct {
  92     DWORD dxgiFormat;
  93     DWORD resourceDimension;
  94     DWORD miscFlag;
  95     DWORD arraySize;
  96     DWORD miscFlags2;
  97 } DDS_HEADER_DXT10;
  98
  99 typedef struct dds_info {
 100     UINT width;
 101     UINT height;
 102     UINT depth;
 103     UINT mip_levels;
 104     UINT array_size;
 105     UINT frame_count;
 106     DXGI_FORMAT format;
 107     WICDdsDimension dimension;
 108     WICDdsAlphaMode alpha_mode;
 109 } dds_info;
 110
 111 typedef struct dds_frame_info {
 112     UINT width;
 113     UINT height;
 114     DXGI_FORMAT format;
 115     UINT bytes_per_block;
 116     UINT block_width;
 117     UINT block_height;
 118     UINT width_in_blocks;
 119     UINT height_in_blocks;
 120 } dds_frame_info;
 121
 122 typedef struct DdsDecoder {
 123     IWICBitmapDecoder IWICBitmapDecoder_iface;
 124     IWICDdsDecoder IWICDdsDecoder_iface;
 125     LONG ref;
 126     BOOL initialized;
 127     IStream *stream;
 128     CRITICAL_SECTION lock;
 129     DDS_HEADER header;
 130     DDS_HEADER_DXT10 header_dxt10;
 131     dds_info info;
 132 } DdsDecoder;
 133
 134 typedef struct DdsFrameDecode {
 135     IWICBitmapFrameDecode IWICBitmapFrameDecode_iface;
 136     IWICDdsFrameDecode IWICDdsFrameDecode_iface;
 137     LONG ref;
 138     BYTE *data;
 139     dds_frame_info info;
 140 } DdsFrameDecode;
 141
 142 static HRESULT WINAPI DdsDecoder_Dds_GetFrame(IWICDdsDecoder *, UINT, UINT, UINT, IWICBitmapFrameDecode **);
 143
 144 static inline BOOL has_extended_header(DDS_HEADER *header)
 145 {
 146     return (header->ddspf.flags & DDPF_FOURCC) &&
 147            (header->ddspf.fourCC == MAKEFOURCC('D', 'X', '1', '0'));
 148 }
 149
 150 static WICDdsDimension get_dimension(DDS_HEADER *header, DDS_HEADER_DXT10 *header_dxt10)
 151 {
 152     if (header_dxt10) {
 153         if (header_dxt10->miscFlag & DDS_RESOURCE_MISC_TEXTURECUBE) return WICDdsTextureCube;
 154         switch (header_dxt10->resourceDimension)
 155         {
 156         case DDS_DIMENSION_TEXTURE1D: return WICDdsTexture1D;
 157         case DDS_DIMENSION_TEXTURE2D: return WICDdsTexture2D;
 158         case DDS_DIMENSION_TEXTURE3D: return WICDdsTexture3D;
 159         default: return WICDdsTexture2D;
 160         }
 161     } else {
 162         if (header->caps2 & DDSCAPS2_CUBEMAP) {
 163             return WICDdsTextureCube;
 164         } else if (header->caps2 & DDSCAPS2_VOLUME) {
 165             return WICDdsTexture3D;
 166         } else {
 167             return WICDdsTexture2D;
 168         }
 169     }
 170 }
 171
 172 static DXGI_FORMAT get_format_from_fourcc(DWORD fourcc)
 173 {
 174     switch (fourcc)
 175     {
 176     case MAKEFOURCC('D', 'X', 'T', '1'):
 177         return DXGI_FORMAT_BC1_UNORM;
 178     case MAKEFOURCC('D', 'X', 'T', '2'):
 179     case MAKEFOURCC('D', 'X', 'T', '3'):
 180         return DXGI_FORMAT_BC2_UNORM;
 181     case MAKEFOURCC('D', 'X', 'T', '4'):
 182     case MAKEFOURCC('D', 'X', 'T', '5'):
 183         return DXGI_FORMAT_BC3_UNORM;
 184     case MAKEFOURCC('D', 'X', '1', '0'):
 185         /* format is indicated in extended header */
 186         return DXGI_FORMAT_UNKNOWN;
 187     default:
 188         /* there are DDS files where fourCC is set directly to DXGI_FORMAT enumeration value */
 189         return fourcc;
 190     }
 191 }
 192
 193 static WICDdsAlphaMode get_alpha_mode_from_fourcc(DWORD fourcc)
 194 {
 195     switch (fourcc)
 196     {
 197     case MAKEFOURCC('D', 'X', 'T', '1'):
 198     case MAKEFOURCC('D', 'X', 'T', '2'):
 199     case MAKEFOURCC('D', 'X', 'T', '4'):
 200         return WICDdsAlphaModePremultiplied;
 201     case MAKEFOURCC('D', 'X', 'T', '3'):
 202     case MAKEFOURCC('D', 'X', 'T', '5'):
 203         return WICDdsAlphaModeStraight;
 204     default:
 205         return WICDdsAlphaModeUnknown;
 206     }
 207 }
 208
 209 static void get_dds_info(dds_info* info, DDS_HEADER *header, DDS_HEADER_DXT10 *header_dxt10)
 210 {
 211     int i;
 212     UINT depth;
 213
 214     info->width = header->width;
 215     info->height = header->height;
 216     info->depth = 1;
 217     info->mip_levels = 1;
 218     info->array_size = 1;
 219     if (header->depth) info->depth = header->depth;
 220     if (header->mipMapCount) info->mip_levels = header->mipMapCount;
 221
 222     if (has_extended_header(header)) {
 223         if (header_dxt10->arraySize) info->array_size = header_dxt10->arraySize;
 224         info->format = header_dxt10->dxgiFormat;
 225         info->dimension = get_dimension(NULL, header_dxt10);
 226         info->alpha_mode = header_dxt10->miscFlags2 & 0x00000008;
 227     } else {
 228         info->format = get_format_from_fourcc(header->ddspf.fourCC);
 229         info->dimension = get_dimension(header, NULL);
 230         info->alpha_mode = get_alpha_mode_from_fourcc(header->ddspf.fourCC);
 231     }
 232
 233     /* get frame count */
 234     if (info->depth == 1) {
 235         info->frame_count = info->array_size * info->mip_levels;
 236     } else {
 237         info->frame_count = 0;
 238         depth = info->depth;
 239         for (i = 0; i < info->mip_levels; i++)
 240         {
 241             info->frame_count += depth;
 242             if (depth > 1) depth /= 2;
 243         }
 244         info->frame_count *= info->array_size;
 245     }
 246 }
 247
 248 static UINT get_bytes_per_block(DXGI_FORMAT format)
 249 {
 250     switch(format)
 251     {
 252         case DXGI_FORMAT_BC1_UNORM:
 253         case DXGI_FORMAT_BC1_TYPELESS:
 254         case DXGI_FORMAT_BC1_UNORM_SRGB:
 255             return 8;
 256         case DXGI_FORMAT_BC2_UNORM:
 257         case DXGI_FORMAT_BC2_TYPELESS:
 258         case DXGI_FORMAT_BC2_UNORM_SRGB:
 259         case DXGI_FORMAT_BC3_UNORM:
 260         case DXGI_FORMAT_BC3_TYPELESS:
 261         case DXGI_FORMAT_BC3_UNORM_SRGB:
 262             return 16;
 263         default:
 264             WARN("DXGI format 0x%x is not supported in DDS decoder\n", format);
 265             return 0;
 266     }
 267 }
 268
 269 static inline DdsDecoder *impl_from_IWICBitmapDecoder(IWICBitmapDecoder *iface)
 270 {
 271     return CONTAINING_RECORD(iface, DdsDecoder, IWICBitmapDecoder_iface);
 272 }
 273
 274 static inline DdsDecoder *impl_from_IWICDdsDecoder(IWICDdsDecoder *iface)
 275 {
 276     return CONTAINING_RECORD(iface, DdsDecoder, IWICDdsDecoder_iface);
 277 }
 278
 279 static inline DdsFrameDecode *impl_from_IWICBitmapFrameDecode(IWICBitmapFrameDecode *iface)
 280 {
 281     return CONTAINING_RECORD(iface, DdsFrameDecode, IWICBitmapFrameDecode_iface);
 282 }
 283
 284 static inline DdsFrameDecode *impl_from_IWICDdsFrameDecode(IWICDdsFrameDecode *iface)
 285 {
 286     return CONTAINING_RECORD(iface, DdsFrameDecode, IWICDdsFrameDecode_iface);
 287 }
 288
 289 static HRESULT WINAPI DdsFrameDecode_QueryInterface(IWICBitmapFrameDecode *iface, REFIID iid,
 290                                                     void **ppv)
 291 {
 292     DdsFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 293     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 294
 295     if (!ppv) return E_INVALIDARG;
 296
 297     if (IsEqualIID(&IID_IUnknown, iid) ||
 298         IsEqualIID(&IID_IWICBitmapSource, iid) ||
 299         IsEqualIID(&IID_IWICBitmapFrameDecode, iid)) {
 300         *ppv = &This->IWICBitmapFrameDecode_iface;
 301     } else if (IsEqualGUID(&IID_IWICDdsFrameDecode, iid)) {
 302         *ppv = &This->IWICDdsFrameDecode_iface;
 303     } else {
 304         *ppv = NULL;
 305         return E_NOINTERFACE;
 306     }
 307
 308     IUnknown_AddRef((IUnknown*)*ppv);
 309     return S_OK;
 310 }
 311
 312 static ULONG WINAPI DdsFrameDecode_AddRef(IWICBitmapFrameDecode *iface)
 313 {
 314     DdsFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 315     ULONG ref = InterlockedIncrement(&This->ref);
 316
 317     TRACE("(%p) refcount=%u\n", iface, ref);
 318
 319     return ref;
 320 }
 321
 322 static ULONG WINAPI DdsFrameDecode_Release(IWICBitmapFrameDecode *iface)
 323 {
 324     DdsFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 325     ULONG ref = InterlockedDecrement(&This->ref);
 326
 327     TRACE("(%p) refcount=%u\n", iface, ref);
 328
 329     if (ref == 0) {
 330         HeapFree(GetProcessHeap(), 0, This->data);
 331         HeapFree(GetProcessHeap(), 0, This);
 332     }
 333
 334     return ref;
 335 }
 336
 337 static HRESULT WINAPI DdsFrameDecode_GetSize(IWICBitmapFrameDecode *iface,
 338                                              UINT *puiWidth, UINT *puiHeight)
 339 {
 340     DdsFrameDecode *This = impl_from_IWICBitmapFrameDecode(iface);
 341
 342     if (!puiWidth || !puiHeight) return E_INVALIDARG;
 343
 344     *puiWidth = This->info.width;
 345     *puiHeight = This->info.height;
 346
 347     TRACE("(%p) -> (%d,%d)\n", iface, *puiWidth, *puiHeight);
 348
 349     return S_OK;
 350 }
 351
 352 static HRESULT WINAPI DdsFrameDecode_GetPixelFormat(IWICBitmapFrameDecode *iface,
 353                                                     WICPixelFormatGUID *pPixelFormat)
 354 {
 355     FIXME("(%p,%p): stub.\n", iface, pPixelFormat);
 356
 357     return E_NOTIMPL;
 358 }
 359
 360 static HRESULT WINAPI DdsFrameDecode_GetResolution(IWICBitmapFrameDecode *iface,
 361                                                    double *pDpiX, double *pDpiY)
 362 {
 363     FIXME("(%p,%p,%p): stub.\n", iface, pDpiX, pDpiY);
 364
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI DdsFrameDecode_CopyPalette(IWICBitmapFrameDecode *iface,
 369                                                  IWICPalette *pIPalette)
 370 {
 371     FIXME("(%p,%p): stub.\n", iface, pIPalette);
 372
 373     return E_NOTIMPL;
 374 }
 375
 376 static HRESULT WINAPI DdsFrameDecode_CopyPixels(IWICBitmapFrameDecode *iface,
 377                                                 const WICRect *prc, UINT cbStride, UINT cbBufferSize, BYTE *pbBuffer)
 378 {
 379     FIXME("(%p,%s,%u,%u,%p): stub.\n", iface, debug_wic_rect(prc), cbStride, cbBufferSize, pbBuffer);
 380
 381     return E_NOTIMPL;
 382 }
 383
 384 static HRESULT WINAPI DdsFrameDecode_GetMetadataQueryReader(IWICBitmapFrameDecode *iface,
 385                                                             IWICMetadataQueryReader **ppIMetadataQueryReader)
 386 {
 387     FIXME("(%p,%p): stub.\n", iface, ppIMetadataQueryReader);
 388
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI DdsFrameDecode_GetColorContexts(IWICBitmapFrameDecode *iface,
 393                                                       UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount)
 394 {
 395     FIXME("(%p,%u,%p,%p): stub.\n", iface, cCount, ppIColorContexts, pcActualCount);
 396
 397     return E_NOTIMPL;
 398 }
 399
 400 static HRESULT WINAPI DdsFrameDecode_GetThumbnail(IWICBitmapFrameDecode *iface,
 401                                                   IWICBitmapSource **ppIThumbnail)
 402 {
 403     FIXME("(%p,%p): stub.\n", iface, ppIThumbnail);
 404
 405     return E_NOTIMPL;
 406 }
 407
 408 static const IWICBitmapFrameDecodeVtbl DdsFrameDecode_Vtbl = {
 409     DdsFrameDecode_QueryInterface,
 410     DdsFrameDecode_AddRef,
 411     DdsFrameDecode_Release,
 412     DdsFrameDecode_GetSize,
 413     DdsFrameDecode_GetPixelFormat,
 414     DdsFrameDecode_GetResolution,
 415     DdsFrameDecode_CopyPalette,
 416     DdsFrameDecode_CopyPixels,
 417     DdsFrameDecode_GetMetadataQueryReader,
 418     DdsFrameDecode_GetColorContexts,
 419     DdsFrameDecode_GetThumbnail
 420 };
 421
 422 static HRESULT WINAPI DdsFrameDecode_Dds_QueryInterface(IWICDdsFrameDecode *iface,
 423                                                         REFIID iid, void **ppv)
 424 {
 425     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 426     return DdsFrameDecode_QueryInterface(&This->IWICBitmapFrameDecode_iface, iid, ppv);
 427 }
 428
 429 static ULONG WINAPI DdsFrameDecode_Dds_AddRef(IWICDdsFrameDecode *iface)
 430 {
 431     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 432     return DdsFrameDecode_AddRef(&This->IWICBitmapFrameDecode_iface);
 433 }
 434
 435 static ULONG WINAPI DdsFrameDecode_Dds_Release(IWICDdsFrameDecode *iface)
 436 {
 437     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 438     return DdsFrameDecode_Release(&This->IWICBitmapFrameDecode_iface);
 439 }
 440
 441 static HRESULT WINAPI DdsFrameDecode_Dds_GetSizeInBlocks(IWICDdsFrameDecode *iface,
 442                                                          UINT *widthInBlocks, UINT *heightInBlocks)
 443 {
 444     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 445
 446     if (!widthInBlocks || !heightInBlocks) return E_INVALIDARG;
 447
 448     *widthInBlocks = This->info.width_in_blocks;
 449     *heightInBlocks = This->info.height_in_blocks;
 450
 451     TRACE("(%p,%p,%p) -> (%d,%d)\n", iface, widthInBlocks, heightInBlocks, *widthInBlocks, *heightInBlocks);
 452
 453     return S_OK;
 454 }
 455
 456 static HRESULT WINAPI DdsFrameDecode_Dds_GetFormatInfo(IWICDdsFrameDecode *iface,
 457                                                        WICDdsFormatInfo *formatInfo)
 458 {
 459     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 460
 461     if (!formatInfo) return E_INVALIDARG;
 462
 463     formatInfo->DxgiFormat = This->info.format;
 464     formatInfo->BytesPerBlock = This->info.bytes_per_block;
 465     formatInfo->BlockWidth = This->info.block_width;
 466     formatInfo->BlockHeight = This->info.block_height;
 467
 468     TRACE("(%p,%p) -> (0x%x,%d,%d,%d)\n", iface, formatInfo,
 469           formatInfo->DxgiFormat, formatInfo->BytesPerBlock, formatInfo->BlockWidth, formatInfo->BlockHeight);
 470
 471     return S_OK;
 472 }
 473
 474 static HRESULT WINAPI DdsFrameDecode_Dds_CopyBlocks(IWICDdsFrameDecode *iface,
 475                                                     const WICRect *boundsInBlocks, UINT stride, UINT bufferSize,
 476                                                     BYTE *buffer)
 477 {
 478     DdsFrameDecode *This = impl_from_IWICDdsFrameDecode(iface);
 479     int x, y, width, height;
 480     UINT bytes_per_block, frame_stride, frame_size, i;
 481     BYTE *data, *dst_buffer;
 482
 483     TRACE("(%p,%p,%u,%u,%p)\n", iface, boundsInBlocks, stride, bufferSize, buffer);
 484
 485     if (!buffer) return E_INVALIDARG;
 486
 487     bytes_per_block = This->info.bytes_per_block;
 488     frame_stride = This->info.width_in_blocks * bytes_per_block;
 489     frame_size = frame_stride * This->info.height_in_blocks;
 490     if (!boundsInBlocks) {
 491         if (stride < frame_stride) return E_INVALIDARG;
 492         if (bufferSize < frame_size) return E_INVALIDARG;
 493         memcpy(buffer, This->data, frame_size);
 494         return S_OK;
 495     }
 496
 497     x = boundsInBlocks->X;
 498     y = boundsInBlocks->Y;
 499     width = boundsInBlocks->Width;
 500     height = boundsInBlocks->Height;
 501     if (x < 0 || y < 0 || width <= 0 || height <= 0 ||
 502         x + width > This->info.width_in_blocks ||
 503         y + height > This->info.height_in_blocks) {
 504         return E_INVALIDARG;
 505     }
 506     if (stride < width * bytes_per_block) return E_INVALIDARG;
 507     if (bufferSize < stride * height) return E_INVALIDARG;
 508
 509     data = This->data + (x + y * This->info.width_in_blocks) * bytes_per_block;
 510     dst_buffer = buffer;
 511     for (i = 0; i < height; i++)
 512     {
 513         memcpy(dst_buffer, data, (size_t)width * bytes_per_block);
 514         data += This->info.width_in_blocks * bytes_per_block;
 515         dst_buffer += stride;
 516     }
 517
 518     return S_OK;
 519 }
 520
 521 static const IWICDdsFrameDecodeVtbl DdsFrameDecode_Dds_Vtbl = {
 522     DdsFrameDecode_Dds_QueryInterface,
 523     DdsFrameDecode_Dds_AddRef,
 524     DdsFrameDecode_Dds_Release,
 525     DdsFrameDecode_Dds_GetSizeInBlocks,
 526     DdsFrameDecode_Dds_GetFormatInfo,
 527     DdsFrameDecode_Dds_CopyBlocks
 528 };
 529
 530 static HRESULT DdsFrameDecode_CreateInstance(DdsFrameDecode **frame_decode)
 531 {
 532     DdsFrameDecode *result;
 533
 534     result = HeapAlloc(GetProcessHeap(), 0, sizeof(*result));
 535     if (!result) return E_OUTOFMEMORY;
 536
 537     result->IWICBitmapFrameDecode_iface.lpVtbl = &DdsFrameDecode_Vtbl;
 538     result->IWICDdsFrameDecode_iface.lpVtbl = &DdsFrameDecode_Dds_Vtbl;
 539     result->ref = 1;
 540
 541     *frame_decode = result;
 542     return S_OK;
 543 }
 544
 545 static HRESULT WINAPI DdsDecoder_QueryInterface(IWICBitmapDecoder *iface, REFIID iid,
 546                                                 void **ppv)
 547 {
 548     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 549     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 550
 551     if (!ppv) return E_INVALIDARG;
 552
 553     if (IsEqualIID(&IID_IUnknown, iid) ||
 554         IsEqualIID(&IID_IWICBitmapDecoder, iid)) {
 555         *ppv = &This->IWICBitmapDecoder_iface;
 556     } else if (IsEqualIID(&IID_IWICDdsDecoder, iid)) {
 557         *ppv = &This->IWICDdsDecoder_iface;
 558     } else {
 559         *ppv = NULL;
 560         return E_NOINTERFACE;
 561     }
 562
 563     IUnknown_AddRef((IUnknown*)*ppv);
 564     return S_OK;
 565 }
 566
 567 static ULONG WINAPI DdsDecoder_AddRef(IWICBitmapDecoder *iface)
 568 {
 569     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 570     ULONG ref = InterlockedIncrement(&This->ref);
 571
 572     TRACE("(%p) refcount=%u\n", iface, ref);
 573
 574     return ref;
 575 }
 576
 577 static ULONG WINAPI DdsDecoder_Release(IWICBitmapDecoder *iface)
 578 {
 579     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 580     ULONG ref = InterlockedDecrement(&This->ref);
 581
 582     TRACE("(%p) refcount=%u\n", iface, ref);
 583
 584     if (ref == 0)
 585     {
 586         This->lock.DebugInfo->Spare[0] = 0;
 587         DeleteCriticalSection(&This->lock);
 588         if (This->stream) IStream_Release(This->stream);
 589         HeapFree(GetProcessHeap(), 0, This);
 590     }
 591
 592     return ref;
 593 }
 594
 595 static HRESULT WINAPI DdsDecoder_QueryCapability(IWICBitmapDecoder *iface, IStream *stream,
 596                                                  DWORD *capability)
 597 {
 598     FIXME("(%p,%p,%p): stub.\n", iface, stream, capability);
 599
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI DdsDecoder_Initialize(IWICBitmapDecoder *iface, IStream *pIStream,
 604                                             WICDecodeOptions cacheOptions)
 605 {
 606     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 607     HRESULT hr;
 608     LARGE_INTEGER seek;
 609     DWORD magic;
 610     ULONG bytesread;
 611
 612     TRACE("(%p,%p,%x)\n", iface, pIStream, cacheOptions);
 613
 614     EnterCriticalSection(&This->lock);
 615
 616     if (This->initialized) {
 617         hr = WINCODEC_ERR_WRONGSTATE;
 618         goto end;
 619     }
 620
 621     seek.QuadPart = 0;
 622     hr = IStream_Seek(pIStream, seek, SEEK_SET, NULL);
 623     if (FAILED(hr)) goto end;
 624
 625     hr = IStream_Read(pIStream, &magic, sizeof(magic), &bytesread);
 626     if (FAILED(hr)) goto end;
 627     if (bytesread != sizeof(magic)) {
 628         hr = WINCODEC_ERR_STREAMREAD;
 629         goto end;
 630     }
 631     if (magic != DDS_MAGIC) {
 632         hr = WINCODEC_ERR_UNKNOWNIMAGEFORMAT;
 633         goto end;
 634     }
 635
 636     hr = IStream_Read(pIStream, &This->header, sizeof(This->header), &bytesread);
 637     if (FAILED(hr)) goto end;
 638     if (bytesread != sizeof(This->header)) {
 639         hr = WINCODEC_ERR_STREAMREAD;
 640         goto end;
 641     }
 642     if (This->header.size != sizeof(This->header)) {
 643         hr = WINCODEC_ERR_BADHEADER;
 644         goto end;
 645     }
 646
 647     if (has_extended_header(&This->header)) {
 648         hr = IStream_Read(pIStream, &This->header_dxt10, sizeof(This->header_dxt10), &bytesread);
 649         if (FAILED(hr)) goto end;
 650         if (bytesread != sizeof(This->header_dxt10)) {
 651             hr = WINCODEC_ERR_STREAMREAD;
 652             goto end;
 653         }
 654     }
 655
 656     get_dds_info(&This->info, &This->header, &This->header_dxt10);
 657
 658     This->initialized = TRUE;
 659     This->stream = pIStream;
 660     IStream_AddRef(pIStream);
 661
 662 end:
 663     LeaveCriticalSection(&This->lock);
 664
 665     return hr;
 666 }
 667
 668 static HRESULT WINAPI DdsDecoder_GetContainerFormat(IWICBitmapDecoder *iface,
 669                                                     GUID *pguidContainerFormat)
 670 {
 671     TRACE("(%p,%p)\n", iface, pguidContainerFormat);
 672
 673     memcpy(pguidContainerFormat, &GUID_ContainerFormatDds, sizeof(GUID));
 674
 675     return S_OK;
 676 }
 677
 678 static HRESULT WINAPI DdsDecoder_GetDecoderInfo(IWICBitmapDecoder *iface,
 679                                                 IWICBitmapDecoderInfo **ppIDecoderInfo)
 680 {
 681     TRACE("(%p,%p)\n", iface, ppIDecoderInfo);
 682
 683     return get_decoder_info(&CLSID_WICDdsDecoder, ppIDecoderInfo);
 684 }
 685
 686 static HRESULT WINAPI DdsDecoder_CopyPalette(IWICBitmapDecoder *iface,
 687                                              IWICPalette *pIPalette)
 688 {
 689     TRACE("(%p,%p)\n", iface, pIPalette);
 690
 691     return WINCODEC_ERR_PALETTEUNAVAILABLE;
 692 }
 693
 694 static HRESULT WINAPI DdsDecoder_GetMetadataQueryReader(IWICBitmapDecoder *iface,
 695                                                         IWICMetadataQueryReader **ppIMetadataQueryReader)
 696 {
 697     if (!ppIMetadataQueryReader) return E_INVALIDARG;
 698
 699     FIXME("(%p,%p)\n", iface, ppIMetadataQueryReader);
 700
 701     return E_NOTIMPL;
 702 }
 703
 704 static HRESULT WINAPI DdsDecoder_GetPreview(IWICBitmapDecoder *iface,
 705                                             IWICBitmapSource **ppIBitmapSource)
 706 {
 707     TRACE("(%p,%p)\n", iface, ppIBitmapSource);
 708
 709     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 710 }
 711
 712 static HRESULT WINAPI DdsDecoder_GetColorContexts(IWICBitmapDecoder *iface,
 713                                                   UINT cCount, IWICColorContext **ppDdslorContexts, UINT *pcActualCount)
 714 {
 715     TRACE("(%p,%u,%p,%p)\n", iface, cCount, ppDdslorContexts, pcActualCount);
 716
 717     return WINCODEC_ERR_UNSUPPORTEDOPERATION;
 718 }
 719
 720 static HRESULT WINAPI DdsDecoder_GetThumbnail(IWICBitmapDecoder *iface,
 721                                               IWICBitmapSource **ppIThumbnail)
 722 {
 723     TRACE("(%p,%p)\n", iface, ppIThumbnail);
 724
 725     return WINCODEC_ERR_CODECNOTHUMBNAIL;
 726 }
 727
 728 static HRESULT WINAPI DdsDecoder_GetFrameCount(IWICBitmapDecoder *iface,
 729                                                UINT *pCount)
 730 {
 731     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 732
 733     if (!pCount) return E_INVALIDARG;
 734     if (!This->initialized) return WINCODEC_ERR_WRONGSTATE;
 735
 736     EnterCriticalSection(&This->lock);
 737
 738     *pCount = This->info.frame_count;
 739
 740     LeaveCriticalSection(&This->lock);
 741
 742     TRACE("(%p) -> %d\n", iface, *pCount);
 743
 744     return S_OK;
 745 }
 746
 747 static HRESULT WINAPI DdsDecoder_GetFrame(IWICBitmapDecoder *iface,
 748                                           UINT index, IWICBitmapFrameDecode **ppIBitmapFrame)
 749 {
 750     DdsDecoder *This = impl_from_IWICBitmapDecoder(iface);
 751     UINT frame_per_texture, array_index, mip_level, slice_index, depth;
 752
 753     TRACE("(%p,%u,%p)\n", iface, index, ppIBitmapFrame);
 754
 755     if (!ppIBitmapFrame) return E_INVALIDARG;
 756
 757     EnterCriticalSection(&This->lock);
 758
 759     if (!This->initialized) {
 760         LeaveCriticalSection(&This->lock);
 761         return WINCODEC_ERR_WRONGSTATE;
 762     }
 763
 764     frame_per_texture = This->info.frame_count / This->info.array_size;
 765     array_index = index / frame_per_texture;
 766     slice_index = index % frame_per_texture;
 767     depth = This->info.depth;
 768     mip_level = 0;
 769     while (slice_index >= depth)
 770     {
 771         slice_index -= depth;
 772         mip_level++;
 773         if (depth > 1) depth /= 2;
 774     }
 775
 776     LeaveCriticalSection(&This->lock);
 777
 778     return DdsDecoder_Dds_GetFrame(&This->IWICDdsDecoder_iface, array_index, mip_level, slice_index, ppIBitmapFrame);
 779 }
 780
 781 static const IWICBitmapDecoderVtbl DdsDecoder_Vtbl = {
 782         DdsDecoder_QueryInterface,
 783         DdsDecoder_AddRef,
 784         DdsDecoder_Release,
 785         DdsDecoder_QueryCapability,
 786         DdsDecoder_Initialize,
 787         DdsDecoder_GetContainerFormat,
 788         DdsDecoder_GetDecoderInfo,
 789         DdsDecoder_CopyPalette,
 790         DdsDecoder_GetMetadataQueryReader,
 791         DdsDecoder_GetPreview,
 792         DdsDecoder_GetColorContexts,
 793         DdsDecoder_GetThumbnail,
 794         DdsDecoder_GetFrameCount,
 795         DdsDecoder_GetFrame
 796 };
 797
 798 static HRESULT WINAPI DdsDecoder_Dds_QueryInterface(IWICDdsDecoder *iface,
 799                                                     REFIID iid, void **ppv)
 800 {
 801     DdsDecoder *This = impl_from_IWICDdsDecoder(iface);
 802     return DdsDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
 803 }
 804
 805 static ULONG WINAPI DdsDecoder_Dds_AddRef(IWICDdsDecoder *iface)
 806 {
 807     DdsDecoder *This = impl_from_IWICDdsDecoder(iface);
 808     return DdsDecoder_AddRef(&This->IWICBitmapDecoder_iface);
 809 }
 810
 811 static ULONG WINAPI DdsDecoder_Dds_Release(IWICDdsDecoder *iface)
 812 {
 813     DdsDecoder *This = impl_from_IWICDdsDecoder(iface);
 814     return DdsDecoder_Release(&This->IWICBitmapDecoder_iface);
 815 }
 816
 817 static HRESULT WINAPI DdsDecoder_Dds_GetParameters(IWICDdsDecoder *iface,
 818                                                    WICDdsParameters *parameters)
 819 {
 820     DdsDecoder *This = impl_from_IWICDdsDecoder(iface);
 821     HRESULT hr;
 822
 823     if (!parameters) return E_INVALIDARG;
 824
 825     EnterCriticalSection(&This->lock);
 826
 827     if (!This->initialized) {
 828         hr = WINCODEC_ERR_WRONGSTATE;
 829         goto end;
 830     }
 831
 832     parameters->Width = This->info.width;
 833     parameters->Height = This->info.height;
 834     parameters->Depth = This->info.depth;
 835     parameters->MipLevels = This->info.mip_levels;
 836     parameters->ArraySize = This->info.array_size;
 837     parameters->DxgiFormat = This->info.format;
 838     parameters->Dimension = This->info.dimension;
 839     parameters->AlphaMode = This->info.alpha_mode;
 840
 841     TRACE("(%p) -> (%dx%d depth=%d mipLevels=%d arraySize=%d dxgiFormat=0x%x dimension=0x%x alphaMode=0x%x)\n",
 842           iface, parameters->Width, parameters->Height, parameters->Depth, parameters->MipLevels,
 843           parameters->ArraySize, parameters->DxgiFormat, parameters->Dimension, parameters->AlphaMode);
 844
 845     hr = S_OK;
 846
 847 end:
 848     LeaveCriticalSection(&This->lock);
 849
 850     return hr;
 851 }
 852
 853 static HRESULT WINAPI DdsDecoder_Dds_GetFrame(IWICDdsDecoder *iface,
 854                                               UINT arrayIndex, UINT mipLevel, UINT sliceIndex,
 855                                               IWICBitmapFrameDecode **bitmapFrame)
 856 {
 857     DdsDecoder *This = impl_from_IWICDdsDecoder(iface);
 858     HRESULT hr;
 859     LARGE_INTEGER seek;
 860     UINT width, height, depth, width_in_blocks, height_in_blocks, size;
 861     UINT frame_width = 0, frame_height = 0, frame_width_in_blocks = 0, frame_height_in_blocks = 0, frame_size = 0;
 862     UINT bytes_per_block, bytesread, i;
 863     DdsFrameDecode *frame_decode = NULL;
 864
 865     TRACE("(%p,%u,%u,%u,%p)\n", iface, arrayIndex, mipLevel, sliceIndex, bitmapFrame);
 866
 867     if (!bitmapFrame) return E_INVALIDARG;
 868
 869     EnterCriticalSection(&This->lock);
 870
 871     if (!This->initialized) {
 872         hr = WINCODEC_ERR_WRONGSTATE;
 873         goto end;
 874     }
 875     if (arrayIndex >= This->info.array_size || mipLevel >= This->info.mip_levels || sliceIndex >= This->info.depth) {
 876         hr = E_INVALIDARG;
 877         goto end;
 878     }
 879
 880     bytes_per_block = get_bytes_per_block(This->info.format);
 881     seek.QuadPart = sizeof(DWORD) + sizeof(DDS_HEADER);
 882     if (has_extended_header(&This->header)) seek.QuadPart += sizeof(DDS_HEADER_DXT10);
 883
 884     width = This->info.width;
 885     height = This->info.height;
 886     depth = This->info.depth;
 887     for (i = 0; i < This->info.mip_levels; i++)
 888     {
 889         width_in_blocks = (width + DDS_BLOCK_WIDTH - 1) / DDS_BLOCK_WIDTH;
 890         height_in_blocks = (height + DDS_BLOCK_HEIGHT - 1) / DDS_BLOCK_HEIGHT;
 891         size = width_in_blocks * height_in_blocks * bytes_per_block;
 892
 893         if (i < mipLevel)  {
 894             seek.QuadPart += size * depth;
 895         } else if (i == mipLevel){
 896             seek.QuadPart += size * sliceIndex;
 897             frame_width = width;
 898             frame_height = height;
 899             frame_width_in_blocks = width_in_blocks;
 900             frame_height_in_blocks = height_in_blocks;
 901             frame_size = frame_width_in_blocks * frame_height_in_blocks * bytes_per_block;
 902             if (arrayIndex == 0) break;
 903         }
 904         seek.QuadPart += arrayIndex * size * depth;
 905
 906         if (width > 1) width /= 2;
 907         if (height > 1) height /= 2;
 908         if (depth > 1) depth /= 2;
 909     }
 910
 911     hr = DdsFrameDecode_CreateInstance(&frame_decode);
 912     if (hr != S_OK) goto end;
 913     frame_decode->info.width = frame_width;
 914     frame_decode->info.height = frame_height;
 915     frame_decode->info.format = This->info.format;
 916     frame_decode->info.bytes_per_block = bytes_per_block;
 917     frame_decode->info.block_width = DDS_BLOCK_WIDTH;
 918     frame_decode->info.block_height = DDS_BLOCK_HEIGHT;
 919     frame_decode->info.width_in_blocks = frame_width_in_blocks;
 920     frame_decode->info.height_in_blocks = frame_height_in_blocks;
 921     frame_decode->data = HeapAlloc(GetProcessHeap(), 0, frame_size);
 922     hr = IStream_Seek(This->stream, seek, SEEK_SET, NULL);
 923     if (hr != S_OK) goto end;
 924     hr = IStream_Read(This->stream, frame_decode->data, frame_size, &bytesread);
 925     if (hr != S_OK || bytesread != frame_size) {
 926         hr = WINCODEC_ERR_STREAMREAD;
 927         goto end;
 928     }
 929     *bitmapFrame = &frame_decode->IWICBitmapFrameDecode_iface;
 930
 931     hr = S_OK;
 932
 933 end:
 934     LeaveCriticalSection(&This->lock);
 935
 936     if (hr != S_OK && frame_decode) DdsFrameDecode_Release(&frame_decode->IWICBitmapFrameDecode_iface);
 937
 938     return hr;
 939 }
 940
 941 static const IWICDdsDecoderVtbl DdsDecoder_Dds_Vtbl = {
 942     DdsDecoder_Dds_QueryInterface,
 943     DdsDecoder_Dds_AddRef,
 944     DdsDecoder_Dds_Release,
 945     DdsDecoder_Dds_GetParameters,
 946     DdsDecoder_Dds_GetFrame
 947 };
 948
 949 HRESULT DdsDecoder_CreateInstance(REFIID iid, void** ppv)
 950 {
 951     DdsDecoder *This;
 952     HRESULT ret;
 953
 954     TRACE("(%s,%p)\n", debugstr_guid(iid), ppv);
 955
 956     *ppv = NULL;
 957
 958     This = HeapAlloc(GetProcessHeap(), 0, sizeof(DdsDecoder));
 959     if (!This) return E_OUTOFMEMORY;
 960
 961     This->IWICBitmapDecoder_iface.lpVtbl = &DdsDecoder_Vtbl;
 962     This->IWICDdsDecoder_iface.lpVtbl = &DdsDecoder_Dds_Vtbl;
 963     This->ref = 1;
 964     This->initialized = FALSE;
 965     This->stream = NULL;
 966     InitializeCriticalSection(&This->lock);
 967     This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DdsDecoder.lock");
 968
 969     ret = IWICBitmapDecoder_QueryInterface(&This->IWICBitmapDecoder_iface, iid, ppv);
 970     IWICBitmapDecoder_Release(&This->IWICBitmapDecoder_iface);
 971
 972     return ret;
 973 }