git.oblomov.eu Git - wine/blob - dlls/windowscodecs/tests/bmpformat.c

   1 /*
   2  * Copyright 2009 Vincent Povirk for CodeWeavers
   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 <stdarg.h>
  20 #include <math.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "initguid.h"
  26 #include "objbase.h"
  27 #include "wincodec.h"
  28 #include "wine/test.h"
  29
  30 static const char testbmp_24bpp[] = {
  31     /* BITMAPFILEHEADER */
  32     66,77, /* "BM" */
  33     50,0,0,0, /* file size */
  34     0,0,0,0, /* reserved */
  35     26,0,0,0, /* offset to bits */
  36     /* BITMAPCOREHEADER */
  37     12,0,0,0, /* header size */
  38     2,0, /* width */
  39     3,0, /* height */
  40     1,0, /* planes */
  41     24,0, /* bit count */
  42     /* bits */
  43     0,0,0,     0,255,0,     0,0,
  44     255,0,0,   255,255,0,   0,0,
  45     255,0,255, 255,255,255, 0,0
  46 };
  47
  48 static void test_decode_24bpp(void)
  49 {
  50     IWICBitmapDecoder *decoder, *decoder2;
  51     IWICBitmapFrameDecode *framedecode;
  52     IWICMetadataQueryReader *queryreader;
  53     IWICColorContext *colorcontext;
  54     IWICBitmapSource *thumbnail;
  55     HRESULT hr;
  56     HGLOBAL hbmpdata;
  57     char *bmpdata;
  58     IStream *bmpstream;
  59     DWORD capability=0;
  60     GUID guidresult;
  61     UINT count=0, width=0, height=0;
  62     double dpiX, dpiY;
  63     BYTE imagedata[36] = {1};
  64     const BYTE expected_imagedata[36] = {
  65         255,0,255, 255,255,255,
  66         255,0,0,   255,255,0,
  67         0,0,0,     0,255,0};
  68     WICRect rc;
  69
  70     hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
  71         &IID_IWICBitmapDecoder, (void**)&decoder);
  72     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
  73     if (FAILED(hr)) return;
  74
  75     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_24bpp));
  76     ok(hbmpdata != 0, "GlobalAlloc failed\n");
  77     if (hbmpdata)
  78     {
  79         bmpdata = GlobalLock(hbmpdata);
  80         memcpy(bmpdata, testbmp_24bpp, sizeof(testbmp_24bpp));
  81         GlobalUnlock(hbmpdata);
  82
  83         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
  84         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
  85         if (SUCCEEDED(hr))
  86         {
  87             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
  88             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
  89
  90             hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
  91             ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
  92             ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
  93
  94             hr = IWICBitmapDecoder_GetMetadataQueryReader(decoder, &queryreader);
  95             ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
  96
  97             hr = IWICBitmapDecoder_GetColorContexts(decoder, 1, &colorcontext, &count);
  98             ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
  99
 100             hr = IWICBitmapDecoder_GetThumbnail(decoder, &thumbnail);
 101             ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
 102
 103             hr = IWICBitmapDecoder_GetPreview(decoder, &thumbnail);
 104             ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
 105
 106             hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
 107             ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
 108             ok(count == 1, "unexpected count %u\n", count);
 109
 110             hr = IWICBitmapDecoder_GetFrame(decoder, 1, &framedecode);
 111             ok(hr == E_INVALIDARG || hr == WINCODEC_ERR_FRAMEMISSING, "GetFrame returned %x\n", hr);
 112
 113             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 114             ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
 115             if (SUCCEEDED(hr))
 116             {
 117                 IWICImagingFactory *factory;
 118                 IWICPalette *palette;
 119
 120                 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
 121                 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
 122                 ok(width == 2, "expected width=2, got %u\n", width);
 123                 ok(height == 3, "expected height=2, got %u\n", height);
 124
 125                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
 126                 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
 127                 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
 128                 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
 129
 130                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
 131                 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
 132                 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat24bppBGR), "unexpected pixel format\n");
 133
 134                 hr = IWICBitmapFrameDecode_GetMetadataQueryReader(framedecode, &queryreader);
 135                 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
 136
 137                 hr = IWICBitmapFrameDecode_GetColorContexts(framedecode, 1, &colorcontext, &count);
 138                 ok(hr == WINCODEC_ERR_UNSUPPORTEDOPERATION, "expected WINCODEC_ERR_UNSUPPORTEDOPERATION, got %x\n", hr);
 139
 140                 hr = IWICBitmapFrameDecode_GetThumbnail(framedecode, &thumbnail);
 141                 ok(hr == WINCODEC_ERR_CODECNOTHUMBNAIL, "expected WINCODEC_ERR_CODECNOTHUMBNAIL, got %x\n", hr);
 142
 143                 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 144                     &IID_IWICImagingFactory, (void**)&factory);
 145                 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 146                 if (SUCCEEDED(hr))
 147                 {
 148                     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 149                     ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
 150                     if (SUCCEEDED(hr))
 151                     {
 152                         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
 153                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 154
 155                         hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
 156                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 157
 158                         IWICPalette_Release(palette);
 159                     }
 160
 161                     IWICImagingFactory_Release(factory);
 162                 }
 163
 164                 rc.X = 0;
 165                 rc.Y = 0;
 166                 rc.Width = 3;
 167                 rc.Height = 3;
 168                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
 169                 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
 170
 171                 rc.X = -1;
 172                 rc.Y = 0;
 173                 rc.Width = 2;
 174                 rc.Height = 3;
 175                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
 176                 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
 177
 178                 rc.X = 0;
 179                 rc.Y = 0;
 180                 rc.Width = 2;
 181                 rc.Height = 3;
 182                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, sizeof(imagedata), imagedata);
 183                 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
 184
 185                 rc.X = 0;
 186                 rc.Y = 0;
 187                 rc.Width = 2;
 188                 rc.Height = 3;
 189                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 4, 5, imagedata);
 190                 ok(hr == E_INVALIDARG, "expected E_INVALIDARG, got %x\n", hr);
 191
 192                 rc.X = 0;
 193                 rc.Y = 0;
 194                 rc.Width = 2;
 195                 rc.Height = 3;
 196                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 6, sizeof(imagedata), imagedata);
 197                 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
 198                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 199
 200                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, NULL, 6, sizeof(imagedata), imagedata);
 201                 ok(SUCCEEDED(hr), "CopyPixels(rect=NULL) failed, hr=%x\n", hr);
 202                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 203
 204                 IWICBitmapFrameDecode_Release(framedecode);
 205             }
 206
 207             /* cannot initialize twice */
 208             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
 209             ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
 210
 211             /* cannot querycapability after initialize */
 212             hr = IWICBitmapDecoder_QueryCapability(decoder, bmpstream, &capability);
 213             ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
 214
 215             hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 216                 &IID_IWICBitmapDecoder, (void**)&decoder2);
 217             ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 218             if (SUCCEEDED(hr))
 219             {
 220                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 221                 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
 222                 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
 223                     "unexpected capabilities: %x\n", capability);
 224
 225                 /* cannot initialize after querycapability */
 226                 hr = IWICBitmapDecoder_Initialize(decoder2, bmpstream, WICDecodeMetadataCacheOnLoad);
 227                 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
 228
 229                 /* cannot querycapability twice */
 230                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 231                 ok(hr == WINCODEC_ERR_WRONGSTATE, "expected WINCODEC_ERR_WRONGSTATE, hr=%x\n", hr);
 232
 233                 IWICBitmapDecoder_Release(decoder2);
 234             }
 235
 236             IStream_Release(bmpstream);
 237         }
 238
 239         GlobalFree(hbmpdata);
 240     }
 241
 242     IWICBitmapDecoder_Release(decoder);
 243 }
 244
 245 static const char testbmp_1bpp[] = {
 246     /* BITMAPFILEHEADER */
 247     66,77, /* "BM" */
 248     40,0,0,0, /* file size */
 249     0,0,0,0, /* reserved */
 250     32,0,0,0, /* offset to bits */
 251     /* BITMAPCOREHEADER */
 252     12,0,0,0, /* header size */
 253     2,0, /* width */
 254     2,0, /* height */
 255     1,0, /* planes */
 256     1,0, /* bit count */
 257     /* color table */
 258     255,0,0,
 259     0,255,0,
 260     /* bits */
 261     0xc0,0,0,0,
 262     0x80,0,0,0
 263 };
 264
 265 static void test_decode_1bpp(void)
 266 {
 267     IWICBitmapDecoder *decoder, *decoder2;
 268     IWICBitmapFrameDecode *framedecode;
 269     HRESULT hr;
 270     HGLOBAL hbmpdata;
 271     char *bmpdata;
 272     IStream *bmpstream;
 273     DWORD capability=0;
 274     GUID guidresult;
 275     UINT count=0, width=0, height=0;
 276     double dpiX, dpiY;
 277     BYTE imagedata[2] = {1};
 278     const BYTE expected_imagedata[2] = {0x80,0xc0};
 279     WICColor palettedata[2] = {1};
 280     const WICColor expected_palettedata[2] = {0xff0000ff,0xff00ff00};
 281     WICRect rc;
 282
 283     hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 284         &IID_IWICBitmapDecoder, (void**)&decoder);
 285     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 286     if (FAILED(hr)) return;
 287
 288     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
 289     ok(hbmpdata != 0, "GlobalAlloc failed\n");
 290     if (hbmpdata)
 291     {
 292         bmpdata = GlobalLock(hbmpdata);
 293         memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
 294         GlobalUnlock(hbmpdata);
 295
 296         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
 297         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 298         if (SUCCEEDED(hr))
 299         {
 300             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
 301             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 302
 303             hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
 304             ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
 305             ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
 306
 307             hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
 308             ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
 309             ok(count == 1, "unexpected count %u\n", count);
 310
 311             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 312             ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
 313             if (SUCCEEDED(hr))
 314             {
 315                 IWICImagingFactory *factory;
 316                 IWICPalette *palette;
 317
 318                 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
 319                 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
 320                 ok(width == 2, "expected width=2, got %u\n", width);
 321                 ok(height == 2, "expected height=2, got %u\n", height);
 322
 323                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
 324                 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
 325                 ok(dpiX == 96.0, "expected dpiX=96.0, got %f\n", dpiX);
 326                 ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
 327
 328                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
 329                 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
 330                 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat1bppIndexed), "unexpected pixel format\n");
 331
 332                 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 333                     &IID_IWICImagingFactory, (void**)&factory);
 334                 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 335                 if (SUCCEEDED(hr))
 336                 {
 337                     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 338                     ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
 339                     if (SUCCEEDED(hr))
 340                     {
 341                         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
 342                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 343
 344                         hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
 345                         ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
 346
 347                         hr = IWICPalette_GetColorCount(palette, &count);
 348                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 349                         ok(count == 2, "expected count=2, got %u\n", count);
 350
 351                         hr = IWICPalette_GetColors(palette, 2, palettedata, &count);
 352                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 353                         ok(count == 2, "expected count=2, got %u\n", count);
 354                         ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
 355
 356                         IWICPalette_Release(palette);
 357                     }
 358
 359                     IWICImagingFactory_Release(factory);
 360                 }
 361
 362                 rc.X = 0;
 363                 rc.Y = 0;
 364                 rc.Width = 2;
 365                 rc.Height = 2;
 366                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
 367                 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
 368                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 369
 370                 IWICBitmapFrameDecode_Release(framedecode);
 371             }
 372
 373             hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 374                 &IID_IWICBitmapDecoder, (void**)&decoder2);
 375             ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 376             if (SUCCEEDED(hr))
 377             {
 378                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 379                 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
 380                 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
 381                     "unexpected capabilities: %x\n", capability);
 382                 IWICBitmapDecoder_Release(decoder2);
 383             }
 384
 385             IStream_Release(bmpstream);
 386         }
 387
 388         GlobalFree(hbmpdata);
 389     }
 390
 391     IWICBitmapDecoder_Release(decoder);
 392 }
 393
 394 static const char testbmp_4bpp[] = {
 395     /* BITMAPFILEHEADER */
 396     66,77, /* "BM" */
 397     82,0,0,0, /* file size */
 398     0,0,0,0, /* reserved */
 399     74,0,0,0, /* offset to bits */
 400     /* BITMAPINFOHEADER */
 401     40,0,0,0, /* header size */
 402     2,0,0,0, /* width */
 403     254,255,255,255, /* height = -2 */
 404     1,0, /* planes */
 405     4,0, /* bit count */
 406     0,0,0,0, /* compression = BI_RGB */
 407     0,0,0,0, /* image size = 0 */
 408     16,39,0,0, /* X pixels per meter = 10000 */
 409     32,78,0,0, /* Y pixels per meter = 20000 */
 410     5,0,0,0, /* colors used */
 411     5,0,0,0, /* colors important */
 412     /* color table */
 413     255,0,0,0,
 414     0,255,0,255,
 415     0,0,255,23,
 416     128,0,128,1,
 417     255,255,255,0,
 418     /* bits */
 419     0x01,0,0,0,
 420     0x23,0,0,0,
 421 };
 422
 423 static void test_decode_4bpp(void)
 424 {
 425     IWICBitmapDecoder *decoder, *decoder2;
 426     IWICBitmapFrameDecode *framedecode;
 427     HRESULT hr;
 428     HGLOBAL hbmpdata;
 429     char *bmpdata;
 430     IStream *bmpstream;
 431     DWORD capability=0;
 432     GUID guidresult;
 433     UINT count=0, width=0, height=0;
 434     double dpiX, dpiY;
 435     BYTE imagedata[2] = {1};
 436     const BYTE expected_imagedata[2] = {0x01,0x23};
 437     WICColor palettedata[5] = {1};
 438     const WICColor expected_palettedata[5] =
 439         {0xff0000ff,0xff00ff00,0xffff0000,0xff800080,0xffffffff};
 440     WICRect rc;
 441
 442     hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 443         &IID_IWICBitmapDecoder, (void**)&decoder);
 444     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 445     if (FAILED(hr)) return;
 446
 447     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_4bpp));
 448     ok(hbmpdata != 0, "GlobalAlloc failed\n");
 449     if (hbmpdata)
 450     {
 451         bmpdata = GlobalLock(hbmpdata);
 452         memcpy(bmpdata, testbmp_4bpp, sizeof(testbmp_4bpp));
 453         GlobalUnlock(hbmpdata);
 454
 455         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
 456         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 457         if (SUCCEEDED(hr))
 458         {
 459             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
 460             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 461
 462             hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
 463             ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
 464             ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
 465
 466             hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
 467             ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
 468             ok(count == 1, "unexpected count %u\n", count);
 469
 470             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 471             ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
 472             if (SUCCEEDED(hr))
 473             {
 474                 IWICImagingFactory *factory;
 475                 IWICPalette *palette;
 476
 477                 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
 478                 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
 479                 ok(width == 2, "expected width=2, got %u\n", width);
 480                 ok(height == 2, "expected height=2, got %u\n", height);
 481
 482                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
 483                 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
 484                 ok(fabs(dpiX - 254.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
 485                 ok(fabs(dpiY - 508.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
 486
 487                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
 488                 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
 489                 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat4bppIndexed), "unexpected pixel format\n");
 490
 491                 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 492                     &IID_IWICImagingFactory, (void**)&factory);
 493                 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 494                 if (SUCCEEDED(hr))
 495                 {
 496                     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 497                     ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
 498                     if (SUCCEEDED(hr))
 499                     {
 500                         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
 501                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 502
 503                         hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
 504                         ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
 505
 506                         hr = IWICPalette_GetColorCount(palette, &count);
 507                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 508                         ok(count == 5, "expected count=5, got %u\n", count);
 509
 510                         hr = IWICPalette_GetColors(palette, 5, palettedata, &count);
 511                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 512                         ok(count == 5, "expected count=5, got %u\n", count);
 513                         ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
 514
 515                         IWICPalette_Release(palette);
 516                     }
 517
 518                     IWICImagingFactory_Release(factory);
 519                 }
 520
 521                 rc.X = 0;
 522                 rc.Y = 0;
 523                 rc.Width = 2;
 524                 rc.Height = 2;
 525                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 1, sizeof(imagedata), imagedata);
 526                 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
 527                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 528
 529                 IWICBitmapFrameDecode_Release(framedecode);
 530             }
 531
 532             hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 533                 &IID_IWICBitmapDecoder, (void**)&decoder2);
 534             ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 535             if (SUCCEEDED(hr))
 536             {
 537                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 538                 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
 539                 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
 540                     "unexpected capabilities: %x\n", capability);
 541                 IWICBitmapDecoder_Release(decoder2);
 542             }
 543
 544             IStream_Release(bmpstream);
 545         }
 546
 547         GlobalFree(hbmpdata);
 548     }
 549
 550     IWICBitmapDecoder_Release(decoder);
 551 }
 552
 553 static const char testbmp_rle8[] = {
 554     /* BITMAPFILEHEADER */
 555     66,77, /* "BM" */
 556     202,0,0,0, /* file size */
 557     0,0,0,0, /* reserved */
 558     122,0,0,0, /* offset to bits */
 559     /* BITMAPINFOHEADER */
 560     40,0,0,0, /* header size */
 561     8,0,0,0, /* width */
 562     8,0,0,0, /* height */
 563     1,0, /* planes */
 564     8,0, /* bit count */
 565     1,0,0,0, /* compression = BI_RLE8 */
 566     80,0,0,0, /* image size */
 567     19,11,0,0, /* X pixels per meter */
 568     19,11,0,0, /* Y pixels per meter */
 569     17,0,0,0, /* colors used */
 570     17,0,0,0, /* colors important */
 571     /* color table */
 572     0,0,0,0,
 573     17,17,17,0,
 574     255,0,0,0,
 575     34,34,34,0,
 576     0,0,204,0,
 577     0,0,221,0,
 578     0,0,238,0,
 579     51,51,51,0,
 580     0,0,255,0,
 581     68,68,68,0,
 582     255,0,255,0,
 583     85,85,85,0,
 584     0,204,0,0,
 585     0,221,0,0,
 586     0,238,0,0,
 587     0,255,0,0,
 588     255,255,255,0,
 589     /* bits */
 590     4,15,0,4,11,9,9,0,0,0,4,14,0,4,3,10,10,7,0,0,4,13,0,4,3,10,10,7,0,0,4,12,0,4,0,1,1,11,0,0,0,4,16,2,16,2,4,4,0,0,0,4,2,16,2,16,4,5,0,0,0,4,16,2,16,2,4,6,0,0,0,4,2,16,2,16,4,8,0,1
 591 };
 592
 593 static void test_decode_rle8(void)
 594 {
 595     IWICBitmapDecoder *decoder, *decoder2;
 596     IWICBitmapFrameDecode *framedecode;
 597     HRESULT hr;
 598     HGLOBAL hbmpdata;
 599     char *bmpdata;
 600     IStream *bmpstream;
 601     DWORD capability=0;
 602     GUID guidresult;
 603     UINT count=0, width=0, height=0;
 604     double dpiX, dpiY;
 605     DWORD imagedata[64] = {1};
 606     const DWORD expected_imagedata[64] = {
 607         0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
 608         0xffffff,0x0000ff,0xffffff,0x0000ff,0xee0000,0xee0000,0xee0000,0xee0000,
 609         0x0000ff,0xffffff,0x0000ff,0xffffff,0xdd0000,0xdd0000,0xdd0000,0xdd0000,
 610         0xffffff,0x0000ff,0xffffff,0x0000ff,0xcc0000,0xcc0000,0xcc0000,0xcc0000,
 611         0x00cc00,0x00cc00,0x00cc00,0x00cc00,0x000000,0x111111,0x111111,0x555555,
 612         0x00dd00,0x00dd00,0x00dd00,0x00dd00,0x222222,0xff00ff,0xff00ff,0x333333,
 613         0x00ee00,0x00ee00,0x00ee00,0x00ee00,0x222222,0xff00ff,0xff00ff,0x333333,
 614         0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x555555,0x444444,0x444444,0x000000};
 615     WICColor palettedata[17] = {1};
 616     const WICColor expected_palettedata[17] = {
 617         0xff000000,0xff111111,0xff0000ff,0xff222222,0xffcc0000,0xffdd0000,
 618         0xffee0000,0xff333333,0xffff0000,0xff444444,0xffff00ff,0xff555555,
 619         0xff00cc00,0xff00dd00,0xff00ee00,0xff00ff00,0xffffffff};
 620     WICRect rc;
 621
 622     hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 623         &IID_IWICBitmapDecoder, (void**)&decoder);
 624     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 625     if (FAILED(hr)) return;
 626
 627     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle8));
 628     ok(hbmpdata != 0, "GlobalAlloc failed\n");
 629     if (hbmpdata)
 630     {
 631         bmpdata = GlobalLock(hbmpdata);
 632         memcpy(bmpdata, testbmp_rle8, sizeof(testbmp_rle8));
 633         GlobalUnlock(hbmpdata);
 634
 635         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
 636         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 637         if (SUCCEEDED(hr))
 638         {
 639             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
 640             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 641
 642             hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
 643             ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
 644             ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
 645
 646             hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
 647             ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
 648             ok(count == 1, "unexpected count %u\n", count);
 649
 650             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 651             ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
 652             if (SUCCEEDED(hr))
 653             {
 654                 IWICImagingFactory *factory;
 655                 IWICPalette *palette;
 656
 657                 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
 658                 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
 659                 ok(width == 8, "expected width=8, got %u\n", width);
 660                 ok(height == 8, "expected height=8, got %u\n", height);
 661
 662                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
 663                 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
 664                 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
 665                 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
 666
 667                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
 668                 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
 669                 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
 670
 671                 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 672                     &IID_IWICImagingFactory, (void**)&factory);
 673                 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 674                 if (SUCCEEDED(hr))
 675                 {
 676                     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 677                     ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
 678                     if (SUCCEEDED(hr))
 679                     {
 680                         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
 681                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 682
 683                         hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
 684                         ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
 685
 686                         hr = IWICPalette_GetColorCount(palette, &count);
 687                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 688                         ok(count == 17, "expected count=17, got %u\n", count);
 689
 690                         hr = IWICPalette_GetColors(palette, 17, palettedata, &count);
 691                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 692                         ok(count == 17, "expected count=17, got %u\n", count);
 693                         ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
 694
 695                         IWICPalette_Release(palette);
 696                     }
 697
 698                     IWICImagingFactory_Release(factory);
 699                 }
 700
 701                 rc.X = 0;
 702                 rc.Y = 0;
 703                 rc.Width = 8;
 704                 rc.Height = 8;
 705                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
 706                 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
 707                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 708
 709                 IWICBitmapFrameDecode_Release(framedecode);
 710             }
 711
 712             hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 713                 &IID_IWICBitmapDecoder, (void**)&decoder2);
 714             ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 715             if (SUCCEEDED(hr))
 716             {
 717                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 718                 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
 719                 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
 720                     "unexpected capabilities: %x\n", capability);
 721                 IWICBitmapDecoder_Release(decoder2);
 722             }
 723
 724             IStream_Release(bmpstream);
 725         }
 726
 727         GlobalFree(hbmpdata);
 728     }
 729
 730     IWICBitmapDecoder_Release(decoder);
 731 }
 732
 733 static const char testbmp_rle4[] = {
 734     /* BITMAPFILEHEADER */
 735     66,77, /* "BM" */
 736     142,0,0,0, /* file size */
 737     0,0,0,0, /* reserved */
 738     78,0,0,0, /* offset to bits */
 739     /* BITMAPINFOHEADER */
 740     40,0,0,0, /* header size */
 741     8,0,0,0, /* width */
 742     8,0,0,0, /* height */
 743     1,0, /* planes */
 744     4,0, /* bit count */
 745     2,0,0,0, /* compression = BI_RLE4 */
 746     64,0,0,0, /* image size */
 747     19,11,0,0, /* X pixels per meter */
 748     19,11,0,0, /* Y pixels per meter */
 749     6,0,0,0, /* colors used */
 750     6,0,0,0, /* colors important */
 751     /* color table */
 752     0,0,0,0,
 753     255,0,0,0,
 754     0,0,255,0,
 755     255,0,255,0,
 756     0,255,0,0,
 757     255,255,255,0,
 758     /* bits */
 759     0,8,68,68,0,0,0,0,0,8,68,68,3,48,0,0,0,8,68,68,3,48,0,0,0,8,68,68,0,0,0,0,0,8,81,81,34,34,0,0,0,8,21,21,34,34,0,0,0,8,81,81,34,34,0,0,0,8,21,21,34,34,0,1
 760 };
 761
 762 static void test_decode_rle4(void)
 763 {
 764     IWICBitmapDecoder *decoder, *decoder2;
 765     IWICBitmapFrameDecode *framedecode;
 766     HRESULT hr;
 767     HGLOBAL hbmpdata;
 768     char *bmpdata;
 769     IStream *bmpstream;
 770     DWORD capability=0;
 771     GUID guidresult;
 772     UINT count=0, width=0, height=0;
 773     double dpiX, dpiY;
 774     DWORD imagedata[64] = {1};
 775     const DWORD expected_imagedata[64] = {
 776         0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
 777         0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
 778         0x0000ff,0xffffff,0x0000ff,0xffffff,0xff0000,0xff0000,0xff0000,0xff0000,
 779         0xffffff,0x0000ff,0xffffff,0x0000ff,0xff0000,0xff0000,0xff0000,0xff0000,
 780         0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000,
 781         0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
 782         0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0xff00ff,0xff00ff,0x000000,
 783         0x00ff00,0x00ff00,0x00ff00,0x00ff00,0x000000,0x000000,0x000000,0x000000};
 784     WICColor palettedata[6] = {1};
 785     const WICColor expected_palettedata[6] = {
 786         0xff000000,0xff0000ff,0xffff0000,0xffff00ff,0xff00ff00,0xffffffff};
 787     WICRect rc;
 788
 789     hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 790         &IID_IWICBitmapDecoder, (void**)&decoder);
 791     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 792     if (FAILED(hr)) return;
 793
 794     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
 795     ok(hbmpdata != 0, "GlobalAlloc failed\n");
 796     if (hbmpdata)
 797     {
 798         bmpdata = GlobalLock(hbmpdata);
 799         memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
 800         GlobalUnlock(hbmpdata);
 801
 802         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
 803         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 804         if (SUCCEEDED(hr))
 805         {
 806             hr = IWICBitmapDecoder_Initialize(decoder, bmpstream, WICDecodeMetadataCacheOnLoad);
 807             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
 808
 809             hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
 810             ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
 811             ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
 812
 813             hr = IWICBitmapDecoder_GetFrameCount(decoder, &count);
 814             ok(SUCCEEDED(hr), "GetFrameCount failed, hr=%x\n", hr);
 815             ok(count == 1, "unexpected count %u\n", count);
 816
 817             hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
 818             ok(SUCCEEDED(hr), "GetFrame failed, hr=%x\n", hr);
 819             if (SUCCEEDED(hr))
 820             {
 821                 IWICImagingFactory *factory;
 822                 IWICPalette *palette;
 823
 824                 hr = IWICBitmapFrameDecode_GetSize(framedecode, &width, &height);
 825                 ok(SUCCEEDED(hr), "GetSize failed, hr=%x\n", hr);
 826                 ok(width == 8, "expected width=8, got %u\n", width);
 827                 ok(height == 8, "expected height=8, got %u\n", height);
 828
 829                 hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
 830                 ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
 831                 ok(fabs(dpiX - 72.0) < 0.01, "expected dpiX=96.0, got %f\n", dpiX);
 832                 ok(fabs(dpiY - 72.0) < 0.01, "expected dpiY=96.0, got %f\n", dpiY);
 833
 834                 hr = IWICBitmapFrameDecode_GetPixelFormat(framedecode, &guidresult);
 835                 ok(SUCCEEDED(hr), "GetPixelFormat failed, hr=%x\n", hr);
 836                 ok(IsEqualGUID(&guidresult, &GUID_WICPixelFormat32bppBGR), "unexpected pixel format\n");
 837
 838                 hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 839                     &IID_IWICImagingFactory, (void**)&factory);
 840                 ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 841                 if (SUCCEEDED(hr))
 842                 {
 843                     hr = IWICImagingFactory_CreatePalette(factory, &palette);
 844                     ok(SUCCEEDED(hr), "CreatePalette failed, hr=%x\n", hr);
 845                     if (SUCCEEDED(hr))
 846                     {
 847                         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
 848                         ok(hr == WINCODEC_ERR_PALETTEUNAVAILABLE, "expected WINCODEC_ERR_PALETTEUNAVAILABLE, got %x\n", hr);
 849
 850                         hr = IWICBitmapFrameDecode_CopyPalette(framedecode, palette);
 851                         ok(SUCCEEDED(hr), "CopyPalette failed, hr=%x\n", hr);
 852
 853                         hr = IWICPalette_GetColorCount(palette, &count);
 854                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 855                         ok(count == 6, "expected count=6, got %u\n", count);
 856
 857                         hr = IWICPalette_GetColors(palette, 6, palettedata, &count);
 858                         ok(SUCCEEDED(hr), "GetColorCount failed, hr=%x\n", hr);
 859                         ok(count == 6, "expected count=6, got %u\n", count);
 860                         ok(!memcmp(palettedata, expected_palettedata, sizeof(palettedata)), "unexpected palette data\n");
 861
 862                         IWICPalette_Release(palette);
 863                     }
 864
 865                     IWICImagingFactory_Release(factory);
 866                 }
 867
 868                 rc.X = 0;
 869                 rc.Y = 0;
 870                 rc.Width = 8;
 871                 rc.Height = 8;
 872                 hr = IWICBitmapFrameDecode_CopyPixels(framedecode, &rc, 32, sizeof(imagedata), (BYTE*)imagedata);
 873                 ok(SUCCEEDED(hr), "CopyPixels failed, hr=%x\n", hr);
 874                 ok(!memcmp(imagedata, expected_imagedata, sizeof(imagedata)), "unexpected image data\n");
 875
 876                 IWICBitmapFrameDecode_Release(framedecode);
 877             }
 878
 879             hr = CoCreateInstance(&CLSID_WICBmpDecoder, NULL, CLSCTX_INPROC_SERVER,
 880                 &IID_IWICBitmapDecoder, (void**)&decoder2);
 881             ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 882             if (SUCCEEDED(hr))
 883             {
 884                 hr = IWICBitmapDecoder_QueryCapability(decoder2, bmpstream, &capability);
 885                 ok(hr == S_OK, "QueryCapability failed, hr=%x\n", hr);
 886                 ok(capability == (WICBitmapDecoderCapabilityCanDecodeAllImages),
 887                     "unexpected capabilities: %x\n", capability);
 888                 IWICBitmapDecoder_Release(decoder2);
 889             }
 890
 891             IStream_Release(bmpstream);
 892         }
 893
 894         GlobalFree(hbmpdata);
 895     }
 896
 897     IWICBitmapDecoder_Release(decoder);
 898 }
 899
 900 static void test_componentinfo(void)
 901 {
 902     IWICImagingFactory *factory;
 903     IWICComponentInfo *info;
 904     IWICBitmapDecoderInfo *decoderinfo;
 905     IWICBitmapDecoder *decoder;
 906     HRESULT hr;
 907     WICBitmapPattern *patterns;
 908     UINT pattern_count, pattern_size;
 909     WICComponentType type;
 910     GUID guidresult;
 911     HGLOBAL hbmpdata;
 912     char *bmpdata;
 913     IStream *bmpstream;
 914     BOOL boolresult;
 915
 916     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
 917         &IID_IWICImagingFactory, (void**)&factory);
 918     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
 919     if (SUCCEEDED(hr))
 920     {
 921         hr = IWICImagingFactory_CreateComponentInfo(factory, &CLSID_WICBmpDecoder, &info);
 922         ok(SUCCEEDED(hr), "CreateComponentInfo failed, hr=%x\n", hr);
 923         if (SUCCEEDED(hr))
 924         {
 925             hr = IWICComponentInfo_GetComponentType(info, &type);
 926             ok(SUCCEEDED(hr), "GetComponentType failed, hr=%x\n", hr);
 927             ok(type == WICDecoder, "got %i, expected WICDecoder\n", type);
 928
 929             hr = IWICComponentInfo_QueryInterface(info, &IID_IWICBitmapDecoderInfo, (void**)&decoderinfo);
 930             ok(SUCCEEDED(hr), "QueryInterface failed, hr=%x\n", hr);
 931             if (SUCCEEDED(hr))
 932             {
 933                 pattern_count = 0;
 934                 pattern_size = 0;
 935                 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, 0, NULL, &pattern_count, &pattern_size);
 936                 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
 937                 ok(pattern_count != 0, "pattern count is 0\n");
 938                 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
 939
 940                 patterns = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, pattern_size);
 941                 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
 942                 ok(SUCCEEDED(hr), "GetPatterns failed, hr=%x\n", hr);
 943                 ok(pattern_count != 0, "pattern count is 0\n");
 944                 ok(pattern_size > pattern_count * sizeof(WICBitmapPattern), "size=%i, count=%i\n", pattern_size, pattern_count);
 945                 ok(patterns[0].Length != 0, "pattern length is 0\n");
 946                 ok(patterns[0].Pattern != NULL, "pattern is NULL\n");
 947                 ok(patterns[0].Mask != NULL, "mask is NULL\n");
 948
 949                 pattern_size -= 1;
 950                 hr = IWICBitmapDecoderInfo_GetPatterns(decoderinfo, pattern_size, patterns, &pattern_count, &pattern_size);
 951                 ok(hr == WINCODEC_ERR_INSUFFICIENTBUFFER, "GetPatterns returned %x, expected WINCODEC_ERR_INSUFFICIENTBUFFER\n", hr);
 952
 953                 HeapFree(GetProcessHeap(), 0, patterns);
 954
 955                 hr = IWICBitmapDecoderInfo_CreateInstance(decoderinfo, &decoder);
 956                 ok(SUCCEEDED(hr), "CreateInstance failed, hr=%x\n", hr);
 957                 if (SUCCEEDED(hr))
 958                 {
 959                     hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
 960                     ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
 961                     ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
 962
 963                     IWICBitmapDecoder_Release(decoder);
 964                 }
 965
 966                 hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_rle4));
 967                 ok(hbmpdata != 0, "GlobalAlloc failed\n");
 968                 if (hbmpdata)
 969                 {
 970                     bmpdata = GlobalLock(hbmpdata);
 971                     memcpy(bmpdata, testbmp_rle4, sizeof(testbmp_rle4));
 972                     GlobalUnlock(hbmpdata);
 973
 974                     hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
 975                     ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
 976                     if (SUCCEEDED(hr))
 977                     {
 978                         boolresult = 0;
 979                         hr = IWICBitmapDecoderInfo_MatchesPattern(decoderinfo, bmpstream, &boolresult);
 980                         ok(SUCCEEDED(hr), "MatchesPattern failed, hr=%x\n", hr);
 981                         ok(boolresult, "pattern not matched\n");
 982
 983                         IStream_Release(bmpstream);
 984                     }
 985
 986                     GlobalFree(hbmpdata);
 987                 }
 988
 989                 IWICBitmapDecoderInfo_Release(decoderinfo);
 990             }
 991
 992             IWICComponentInfo_Release(info);
 993         }
 994
 995         IWICImagingFactory_Release(factory);
 996     }
 997 }
 998
 999 static void test_createfromstream(void)
1000 {
1001     IWICBitmapDecoder *decoder;
1002     IWICImagingFactory *factory;
1003     HRESULT hr;
1004     HGLOBAL hbmpdata;
1005     char *bmpdata;
1006     IStream *bmpstream;
1007     GUID guidresult;
1008
1009     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1010         &IID_IWICImagingFactory, (void**)&factory);
1011     ok(SUCCEEDED(hr), "CoCreateInstance failed, hr=%x\n", hr);
1012     if (FAILED(hr)) return;
1013
1014     hbmpdata = GlobalAlloc(GMEM_MOVEABLE, sizeof(testbmp_1bpp));
1015     ok(hbmpdata != 0, "GlobalAlloc failed\n");
1016     if (hbmpdata)
1017     {
1018         bmpdata = GlobalLock(hbmpdata);
1019         memcpy(bmpdata, testbmp_1bpp, sizeof(testbmp_1bpp));
1020         GlobalUnlock(hbmpdata);
1021
1022         hr = CreateStreamOnHGlobal(hbmpdata, FALSE, &bmpstream);
1023         ok(SUCCEEDED(hr), "CreateStreamOnHGlobal failed, hr=%x\n", hr);
1024         if (SUCCEEDED(hr))
1025         {
1026             hr = IWICImagingFactory_CreateDecoderFromStream(factory, bmpstream,
1027                 NULL, WICDecodeMetadataCacheOnDemand, &decoder);
1028             ok(SUCCEEDED(hr), "CreateDecoderFromStream failed, hr=%x\n", hr);
1029             if (SUCCEEDED(hr))
1030             {
1031                 hr = IWICBitmapDecoder_GetContainerFormat(decoder, &guidresult);
1032                 ok(SUCCEEDED(hr), "GetContainerFormat failed, hr=%x\n", hr);
1033                 ok(IsEqualGUID(&guidresult, &GUID_ContainerFormatBmp), "unexpected container format\n");
1034
1035                 IWICBitmapDecoder_Release(decoder);
1036             }
1037
1038             IStream_Release(bmpstream);
1039         }
1040
1041         GlobalFree(hbmpdata);
1042     }
1043
1044     IWICImagingFactory_Release(factory);
1045 }
1046
1047 /* 1x1 pixel gif, missing trailer */
1048 static unsigned char gifimage_notrailer[] = {
1049 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x71,0xff,0xff,0xff,
1050 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
1051 0x01,0x00
1052 };
1053
1054 static void test_gif_notrailer(void)
1055 {
1056     IWICBitmapDecoder *decoder;
1057     IWICImagingFactory *factory;
1058     HRESULT hr;
1059     IWICStream *gifstream;
1060     IWICBitmapFrameDecode *framedecode;
1061     double dpiX = 0.0, dpiY = 0.0;
1062     UINT framecount;
1063
1064     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
1065         &IID_IWICImagingFactory, (void**)&factory);
1066     ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
1067     if (FAILED(hr)) return;
1068
1069     hr = IWICImagingFactory_CreateStream(factory, &gifstream);
1070     ok(hr == S_OK, "CreateStream failed, hr=%x\n", hr);
1071     if (SUCCEEDED(hr))
1072     {
1073         hr = IWICStream_InitializeFromMemory(gifstream, gifimage_notrailer,
1074             sizeof(gifimage_notrailer));
1075         ok(hr == S_OK, "InitializeFromMemory failed, hr=%x\n", hr);
1076
1077         if (SUCCEEDED(hr))
1078         {
1079             hr = CoCreateInstance(&CLSID_WICGifDecoder, NULL, CLSCTX_INPROC_SERVER,
1080                 &IID_IWICBitmapDecoder, (void**)&decoder);
1081             ok(hr == S_OK, "CoCreateInstance failed, hr=%x\n", hr);
1082         }
1083
1084         if (SUCCEEDED(hr))
1085         {
1086             hr = IWICBitmapDecoder_Initialize(decoder, (IStream*)gifstream,
1087                 WICDecodeMetadataCacheOnDemand);
1088             ok(hr == S_OK, "Initialize failed, hr=%x\n", hr);
1089
1090             if (SUCCEEDED(hr))
1091             {
1092                 hr = IWICBitmapDecoder_GetFrame(decoder, 0, &framedecode);
1093                 ok(hr == S_OK, "GetFrame failed, hr=%x\n", hr);
1094                 if (SUCCEEDED(hr))
1095                 {
1096                     hr = IWICBitmapFrameDecode_GetResolution(framedecode, &dpiX, &dpiY);
1097                     ok(SUCCEEDED(hr), "GetResolution failed, hr=%x\n", hr);
1098                     ok(dpiX == 48.0, "expected dpiX=48.0, got %f\n", dpiX);
1099                     ok(dpiY == 96.0, "expected dpiY=96.0, got %f\n", dpiY);
1100
1101                     IWICBitmapFrameDecode_Release(framedecode);
1102                 }
1103             }
1104
1105             if (SUCCEEDED(hr))
1106             {
1107                 hr = IWICBitmapDecoder_GetFrameCount(decoder, &framecount);
1108                 ok(hr == S_OK, "GetFrameCount failed, hr=%x\n", hr);
1109                 ok(framecount == 1, "framecount=%u\n", framecount);
1110             }
1111
1112             IWICBitmapDecoder_Release(decoder);
1113         }
1114
1115         IWICStream_Release(gifstream);
1116     }
1117
1118     IWICImagingFactory_Release(factory);
1119 }
1120
1121 START_TEST(bmpformat)
1122 {
1123     CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1124
1125     test_decode_24bpp();
1126     test_decode_1bpp();
1127     test_decode_4bpp();
1128     test_decode_rle8();
1129     test_decode_rle4();
1130     test_componentinfo();
1131     test_createfromstream();
1132     test_gif_notrailer();
1133
1134     CoUninitialize();
1135 }