dlls/gdiplus/image.c

   1 /*
   2  * Copyright (C) 2007 Google (Evan Stade)
   3  * Copyright (C) 2012,2016 Dmitry Timoshkov
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include <stdarg.h>
  21 #include <assert.h>
  22
  23 #define NONAMELESSUNION
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "wingdi.h"
  29
  30 #define COBJMACROS
  31 #include "objbase.h"
  32 #include "olectl.h"
  33 #include "ole2.h"
  34
  35 #include "initguid.h"
  36 #include "wincodec.h"
  37 #include "gdiplus.h"
  38 #include "gdiplus_private.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
  42
  43 HRESULT WINAPI WICCreateImagingFactory_Proxy(UINT, IWICImagingFactory**);
  44
  45 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
  46 #define WMF_PLACEABLE_KEY 0x9ac6cdd7
  47
  48 static const struct
  49 {
  50     const WICPixelFormatGUID *wic_format;
  51     PixelFormat gdip_format;
  52     /* predefined palette type to use for pixel format conversions */
  53     WICBitmapPaletteType palette_type;
  54 } pixel_formats[] =
  55 {
  56     { &GUID_WICPixelFormatBlackWhite, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
  57     { &GUID_WICPixelFormat1bppIndexed, PixelFormat1bppIndexed, WICBitmapPaletteTypeFixedBW },
  58     { &GUID_WICPixelFormat8bppGray, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedGray256 },
  59     { &GUID_WICPixelFormat8bppIndexed, PixelFormat8bppIndexed, WICBitmapPaletteTypeFixedHalftone256 },
  60     { &GUID_WICPixelFormat16bppBGR555, PixelFormat16bppRGB555, WICBitmapPaletteTypeFixedHalftone256 },
  61     { &GUID_WICPixelFormat24bppBGR, PixelFormat24bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
  62     { &GUID_WICPixelFormat32bppBGR, PixelFormat32bppRGB, WICBitmapPaletteTypeFixedHalftone256 },
  63     { &GUID_WICPixelFormat32bppBGRA, PixelFormat32bppARGB, WICBitmapPaletteTypeFixedHalftone256 },
  64     { &GUID_WICPixelFormat32bppPBGRA, PixelFormat32bppPARGB, WICBitmapPaletteTypeFixedHalftone256 },
  65     { NULL }
  66 };
  67
  68 static ColorPalette *get_palette(IWICBitmapFrameDecode *frame, WICBitmapPaletteType palette_type)
  69 {
  70     HRESULT hr;
  71     IWICImagingFactory *factory;
  72     IWICPalette *wic_palette;
  73     ColorPalette *palette = NULL;
  74
  75     hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
  76     if (hr != S_OK) return NULL;
  77
  78     hr = IWICImagingFactory_CreatePalette(factory, &wic_palette);
  79     if (hr == S_OK)
  80     {
  81         hr = WINCODEC_ERR_PALETTEUNAVAILABLE;
  82         if (frame)
  83             hr = IWICBitmapFrameDecode_CopyPalette(frame, wic_palette);
  84         if (hr != S_OK)
  85         {
  86             TRACE("using predefined palette %#x\n", palette_type);
  87             hr = IWICPalette_InitializePredefined(wic_palette, palette_type, FALSE);
  88         }
  89         if (hr == S_OK)
  90         {
  91             WICBitmapPaletteType type;
  92             BOOL alpha;
  93             UINT count;
  94
  95             IWICPalette_GetColorCount(wic_palette, &count);
  96             palette = heap_alloc(2 * sizeof(UINT) + count * sizeof(ARGB));
  97             IWICPalette_GetColors(wic_palette, count, palette->Entries, &palette->Count);
  98
  99             IWICPalette_GetType(wic_palette, &type);
 100             switch(type) {
 101                 case WICBitmapPaletteTypeFixedGray4:
 102                 case WICBitmapPaletteTypeFixedGray16:
 103                 case WICBitmapPaletteTypeFixedGray256:
 104                     palette->Flags = PaletteFlagsGrayScale;
 105                     break;
 106                 case WICBitmapPaletteTypeFixedHalftone8:
 107                 case WICBitmapPaletteTypeFixedHalftone27:
 108                 case WICBitmapPaletteTypeFixedHalftone64:
 109                 case WICBitmapPaletteTypeFixedHalftone125:
 110                 case WICBitmapPaletteTypeFixedHalftone216:
 111                 case WICBitmapPaletteTypeFixedHalftone252:
 112                 case WICBitmapPaletteTypeFixedHalftone256:
 113                     palette->Flags = PaletteFlagsHalftone;
 114                     break;
 115                 default:
 116                     palette->Flags = 0;
 117             }
 118             IWICPalette_HasAlpha(wic_palette, &alpha);
 119             if(alpha)
 120                 palette->Flags |= PaletteFlagsHasAlpha;
 121         }
 122         IWICPalette_Release(wic_palette);
 123     }
 124     IWICImagingFactory_Release(factory);
 125     return palette;
 126 }
 127
 128 GpStatus WINGDIPAPI GdipBitmapApplyEffect(GpBitmap* bitmap, CGpEffect* effect,
 129     RECT* roi, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
 130 {
 131     FIXME("(%p %p %p %d %p %p): stub\n", bitmap, effect, roi, useAuxData, auxData, auxDataSize);
 132     /*
 133      * Note: According to Jose Roca's GDI+ docs, this function is not
 134      * implemented in Windows's GDI+.
 135      */
 136     return NotImplemented;
 137 }
 138
 139 GpStatus WINGDIPAPI GdipBitmapCreateApplyEffect(GpBitmap** inputBitmaps,
 140     INT numInputs, CGpEffect* effect, RECT* roi, RECT* outputRect,
 141     GpBitmap** outputBitmap, BOOL useAuxData, VOID** auxData, INT* auxDataSize)
 142 {
 143     FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps, numInputs, effect, roi, outputRect, outputBitmap, useAuxData, auxData, auxDataSize);
 144     /*
 145      * Note: According to Jose Roca's GDI+ docs, this function is not
 146      * implemented in Windows's GDI+.
 147      */
 148     return NotImplemented;
 149 }
 150
 151 static inline void getpixel_1bppIndexed(BYTE *index, const BYTE *row, UINT x)
 152 {
 153     *index = (row[x/8]>>(7-x%8)) & 1;
 154 }
 155
 156 static inline void getpixel_4bppIndexed(BYTE *index, const BYTE *row, UINT x)
 157 {
 158     if (x & 1)
 159         *index = row[x/2]&0xf;
 160     else
 161         *index = row[x/2]>>4;
 162 }
 163
 164 static inline void getpixel_8bppIndexed(BYTE *index, const BYTE *row, UINT x)
 165 {
 166     *index = row[x];
 167 }
 168
 169 static inline void getpixel_16bppGrayScale(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 170     const BYTE *row, UINT x)
 171 {
 172     *r = *g = *b = row[x*2+1];
 173     *a = 255;
 174 }
 175
 176 static inline void getpixel_16bppRGB555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 177     const BYTE *row, UINT x)
 178 {
 179     WORD pixel = *((const WORD*)(row)+x);
 180     *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
 181     *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
 182     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 183     *a = 255;
 184 }
 185
 186 static inline void getpixel_16bppRGB565(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 187     const BYTE *row, UINT x)
 188 {
 189     WORD pixel = *((const WORD*)(row)+x);
 190     *r = (pixel>>8&0xf8)|(pixel>>13&0x7);
 191     *g = (pixel>>3&0xfc)|(pixel>>9&0x3);
 192     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 193     *a = 255;
 194 }
 195
 196 static inline void getpixel_16bppARGB1555(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 197     const BYTE *row, UINT x)
 198 {
 199     WORD pixel = *((const WORD*)(row)+x);
 200     *r = (pixel>>7&0xf8)|(pixel>>12&0x7);
 201     *g = (pixel>>2&0xf8)|(pixel>>6&0x7);
 202     *b = (pixel<<3&0xf8)|(pixel>>2&0x7);
 203     if ((pixel&0x8000) == 0x8000)
 204         *a = 255;
 205     else
 206         *a = 0;
 207 }
 208
 209 static inline void getpixel_24bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 210     const BYTE *row, UINT x)
 211 {
 212     *r = row[x*3+2];
 213     *g = row[x*3+1];
 214     *b = row[x*3];
 215     *a = 255;
 216 }
 217
 218 static inline void getpixel_32bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 219     const BYTE *row, UINT x)
 220 {
 221     *r = row[x*4+2];
 222     *g = row[x*4+1];
 223     *b = row[x*4];
 224     *a = 255;
 225 }
 226
 227 static inline void getpixel_32bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 228     const BYTE *row, UINT x)
 229 {
 230     *r = row[x*4+2];
 231     *g = row[x*4+1];
 232     *b = row[x*4];
 233     *a = row[x*4+3];
 234 }
 235
 236 static inline void getpixel_32bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 237     const BYTE *row, UINT x)
 238 {
 239     *a = row[x*4+3];
 240     if (*a == 0)
 241         *r = *g = *b = 0;
 242     else
 243     {
 244         *r = row[x*4+2] * 255 / *a;
 245         *g = row[x*4+1] * 255 / *a;
 246         *b = row[x*4] * 255 / *a;
 247     }
 248 }
 249
 250 static inline void getpixel_48bppRGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 251     const BYTE *row, UINT x)
 252 {
 253     *r = row[x*6+5];
 254     *g = row[x*6+3];
 255     *b = row[x*6+1];
 256     *a = 255;
 257 }
 258
 259 static inline void getpixel_64bppARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 260     const BYTE *row, UINT x)
 261 {
 262     *r = row[x*8+5];
 263     *g = row[x*8+3];
 264     *b = row[x*8+1];
 265     *a = row[x*8+7];
 266 }
 267
 268 static inline void getpixel_64bppPARGB(BYTE *r, BYTE *g, BYTE *b, BYTE *a,
 269     const BYTE *row, UINT x)
 270 {
 271     *a = row[x*8+7];
 272     if (*a == 0)
 273         *r = *g = *b = 0;
 274     else
 275     {
 276         *r = row[x*8+5] * 255 / *a;
 277         *g = row[x*8+3] * 255 / *a;
 278         *b = row[x*8+1] * 255 / *a;
 279     }
 280 }
 281
 282 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
 283     ARGB *color)
 284 {
 285     BYTE r, g, b, a;
 286     BYTE index;
 287     BYTE *row;
 288
 289     if(!bitmap || !color ||
 290        x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
 291         return InvalidParameter;
 292
 293     row = bitmap->bits+bitmap->stride*y;
 294
 295     switch (bitmap->format)
 296     {
 297         case PixelFormat1bppIndexed:
 298             getpixel_1bppIndexed(&index,row,x);
 299             break;
 300         case PixelFormat4bppIndexed:
 301             getpixel_4bppIndexed(&index,row,x);
 302             break;
 303         case PixelFormat8bppIndexed:
 304             getpixel_8bppIndexed(&index,row,x);
 305             break;
 306         case PixelFormat16bppGrayScale:
 307             getpixel_16bppGrayScale(&r,&g,&b,&a,row,x);
 308             break;
 309         case PixelFormat16bppRGB555:
 310             getpixel_16bppRGB555(&r,&g,&b,&a,row,x);
 311             break;
 312         case PixelFormat16bppRGB565:
 313             getpixel_16bppRGB565(&r,&g,&b,&a,row,x);
 314             break;
 315         case PixelFormat16bppARGB1555:
 316             getpixel_16bppARGB1555(&r,&g,&b,&a,row,x);
 317             break;
 318         case PixelFormat24bppRGB:
 319             getpixel_24bppRGB(&r,&g,&b,&a,row,x);
 320             break;
 321         case PixelFormat32bppRGB:
 322             getpixel_32bppRGB(&r,&g,&b,&a,row,x);
 323             break;
 324         case PixelFormat32bppARGB:
 325             getpixel_32bppARGB(&r,&g,&b,&a,row,x);
 326             break;
 327         case PixelFormat32bppPARGB:
 328             getpixel_32bppPARGB(&r,&g,&b,&a,row,x);
 329             break;
 330         case PixelFormat48bppRGB:
 331             getpixel_48bppRGB(&r,&g,&b,&a,row,x);
 332             break;
 333         case PixelFormat64bppARGB:
 334             getpixel_64bppARGB(&r,&g,&b,&a,row,x);
 335             break;
 336         case PixelFormat64bppPARGB:
 337             getpixel_64bppPARGB(&r,&g,&b,&a,row,x);
 338             break;
 339         default:
 340             FIXME("not implemented for format 0x%x\n", bitmap->format);
 341             return NotImplemented;
 342     }
 343
 344     if (bitmap->format & PixelFormatIndexed)
 345         *color = bitmap->image.palette->Entries[index];
 346     else
 347         *color = a<<24|r<<16|g<<8|b;
 348
 349     return Ok;
 350 }
 351
 352 static inline UINT get_palette_index(BYTE r, BYTE g, BYTE b, BYTE a, ColorPalette *palette)
 353 {
 354     BYTE index = 0;
 355     int best_distance = 0x7fff;
 356     int distance;
 357     UINT i;
 358
 359     if (!palette) return 0;
 360     /* This algorithm scans entire palette,
 361        computes difference from desired color (all color components have equal weight)
 362        and returns the index of color with least difference.
 363
 364        Note: Maybe it could be replaced with a better algorithm for better image quality
 365        and performance, though better algorithm would probably need some pre-built lookup
 366        tables and thus may actually be slower if this method is called only few times per
 367        every image.
 368     */
 369     for(i=0;i<palette->Count;i++) {
 370         ARGB color=palette->Entries[i];
 371         distance=abs(b-(color & 0xff)) + abs(g-(color>>8 & 0xff)) + abs(r-(color>>16 & 0xff)) + abs(a-(color>>24 & 0xff));
 372         if (distance<best_distance) {
 373             best_distance=distance;
 374             index=i;
 375         }
 376     }
 377     return index;
 378 }
 379
 380 static inline void setpixel_8bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 381     BYTE *row, UINT x, ColorPalette *palette)
 382 {
 383      BYTE index = get_palette_index(r,g,b,a,palette);
 384      row[x]=index;
 385 }
 386
 387 static inline void setpixel_1bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 388     BYTE *row, UINT x, ColorPalette *palette)
 389 {
 390     row[x/8]  = (row[x/8] & ~(1<<(7-x%8))) | (get_palette_index(r,g,b,a,palette)<<(7-x%8));
 391 }
 392
 393 static inline void setpixel_4bppIndexed(BYTE r, BYTE g, BYTE b, BYTE a,
 394     BYTE *row, UINT x, ColorPalette *palette)
 395 {
 396     if (x & 1)
 397         row[x/2] = (row[x/2] & 0xf0) | get_palette_index(r,g,b,a,palette);
 398     else
 399         row[x/2] = (row[x/2] & 0x0f) | get_palette_index(r,g,b,a,palette)<<4;
 400 }
 401
 402 static inline void setpixel_16bppGrayScale(BYTE r, BYTE g, BYTE b, BYTE a,
 403     BYTE *row, UINT x)
 404 {
 405     *((WORD*)(row)+x) = (r+g+b)*85;
 406 }
 407
 408 static inline void setpixel_16bppRGB555(BYTE r, BYTE g, BYTE b, BYTE a,
 409     BYTE *row, UINT x)
 410 {
 411     *((WORD*)(row)+x) = (r<<7&0x7c00)|
 412                         (g<<2&0x03e0)|
 413                         (b>>3&0x001f);
 414 }
 415
 416 static inline void setpixel_16bppRGB565(BYTE r, BYTE g, BYTE b, BYTE a,
 417     BYTE *row, UINT x)
 418 {
 419     *((WORD*)(row)+x) = (r<<8&0xf800)|
 420                          (g<<3&0x07e0)|
 421                          (b>>3&0x001f);
 422 }
 423
 424 static inline void setpixel_16bppARGB1555(BYTE r, BYTE g, BYTE b, BYTE a,
 425     BYTE *row, UINT x)
 426 {
 427     *((WORD*)(row)+x) = (a<<8&0x8000)|
 428                         (r<<7&0x7c00)|
 429                         (g<<2&0x03e0)|
 430                         (b>>3&0x001f);
 431 }
 432
 433 static inline void setpixel_24bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 434     BYTE *row, UINT x)
 435 {
 436     row[x*3+2] = r;
 437     row[x*3+1] = g;
 438     row[x*3] = b;
 439 }
 440
 441 static inline void setpixel_32bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 442     BYTE *row, UINT x)
 443 {
 444     *((DWORD*)(row)+x) = (r<<16)|(g<<8)|b;
 445 }
 446
 447 static inline void setpixel_32bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 448     BYTE *row, UINT x)
 449 {
 450     *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
 451 }
 452
 453 static inline void setpixel_32bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 454     BYTE *row, UINT x)
 455 {
 456     r = r * a / 255;
 457     g = g * a / 255;
 458     b = b * a / 255;
 459     *((DWORD*)(row)+x) = (a<<24)|(r<<16)|(g<<8)|b;
 460 }
 461
 462 static inline void setpixel_48bppRGB(BYTE r, BYTE g, BYTE b, BYTE a,
 463     BYTE *row, UINT x)
 464 {
 465     row[x*6+5] = row[x*6+4] = r;
 466     row[x*6+3] = row[x*6+2] = g;
 467     row[x*6+1] = row[x*6] = b;
 468 }
 469
 470 static inline void setpixel_64bppARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 471     BYTE *row, UINT x)
 472 {
 473     UINT64 a64=a, r64=r, g64=g, b64=b;
 474     *((UINT64*)(row)+x) = (a64<<56)|(a64<<48)|(r64<<40)|(r64<<32)|(g64<<24)|(g64<<16)|(b64<<8)|b64;
 475 }
 476
 477 static inline void setpixel_64bppPARGB(BYTE r, BYTE g, BYTE b, BYTE a,
 478     BYTE *row, UINT x)
 479 {
 480     UINT64 a64, r64, g64, b64;
 481     a64 = a * 257;
 482     r64 = r * a / 255;
 483     g64 = g * a / 255;
 484     b64 = b * a / 255;
 485     *((UINT64*)(row)+x) = (a64<<48)|(r64<<32)|(g64<<16)|b64;
 486 }
 487
 488 GpStatus WINGDIPAPI GdipBitmapSetPixel(GpBitmap* bitmap, INT x, INT y,
 489     ARGB color)
 490 {
 491     BYTE a, r, g, b;
 492     BYTE *row;
 493
 494     if(!bitmap || x < 0 || y < 0 || x >= bitmap->width || y >= bitmap->height)
 495         return InvalidParameter;
 496
 497     a = color>>24;
 498     r = color>>16;
 499     g = color>>8;
 500     b = color;
 501
 502     row = bitmap->bits + bitmap->stride * y;
 503
 504     switch (bitmap->format)
 505     {
 506         case PixelFormat16bppGrayScale:
 507             setpixel_16bppGrayScale(r,g,b,a,row,x);
 508             break;
 509         case PixelFormat16bppRGB555:
 510             setpixel_16bppRGB555(r,g,b,a,row,x);
 511             break;
 512         case PixelFormat16bppRGB565:
 513             setpixel_16bppRGB565(r,g,b,a,row,x);
 514             break;
 515         case PixelFormat16bppARGB1555:
 516             setpixel_16bppARGB1555(r,g,b,a,row,x);
 517             break;
 518         case PixelFormat24bppRGB:
 519             setpixel_24bppRGB(r,g,b,a,row,x);
 520             break;
 521         case PixelFormat32bppRGB:
 522             setpixel_32bppRGB(r,g,b,a,row,x);
 523             break;
 524         case PixelFormat32bppARGB:
 525             setpixel_32bppARGB(r,g,b,a,row,x);
 526             break;
 527         case PixelFormat32bppPARGB:
 528             setpixel_32bppPARGB(r,g,b,a,row,x);
 529             break;
 530         case PixelFormat48bppRGB:
 531             setpixel_48bppRGB(r,g,b,a,row,x);
 532             break;
 533         case PixelFormat64bppARGB:
 534             setpixel_64bppARGB(r,g,b,a,row,x);
 535             break;
 536         case PixelFormat64bppPARGB:
 537             setpixel_64bppPARGB(r,g,b,a,row,x);
 538             break;
 539         case PixelFormat8bppIndexed:
 540             setpixel_8bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 541             break;
 542         case PixelFormat4bppIndexed:
 543             setpixel_4bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 544             break;
 545         case PixelFormat1bppIndexed:
 546             setpixel_1bppIndexed(r,g,b,a,row,x,bitmap->image.palette);
 547             break;
 548         default:
 549             FIXME("not implemented for format 0x%x\n", bitmap->format);
 550             return NotImplemented;
 551     }
 552
 553     return Ok;
 554 }
 555
 556 GpStatus convert_pixels(INT width, INT height,
 557     INT dst_stride, BYTE *dst_bits, PixelFormat dst_format,
 558     INT src_stride, const BYTE *src_bits, PixelFormat src_format,
 559     ColorPalette *palette)
 560 {
 561     INT x, y;
 562
 563     if (src_format == dst_format ||
 564         (dst_format == PixelFormat32bppRGB && PIXELFORMATBPP(src_format) == 32))
 565     {
 566         UINT widthbytes = PIXELFORMATBPP(src_format) * width / 8;
 567         for (y=0; y<height; y++)
 568             memcpy(dst_bits+dst_stride*y, src_bits+src_stride*y, widthbytes);
 569         return Ok;
 570     }
 571
 572 #define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
 573     for (y=0; y<height; y++) \
 574         for (x=0; x<width; x++) { \
 575             BYTE index; \
 576             ARGB argb; \
 577             BYTE *color = (BYTE *)&argb; \
 578             getpixel_function(&index, src_bits+src_stride*y, x); \
 579             argb = (palette && index < palette->Count) ? palette->Entries[index] : 0; \
 580             setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
 581         } \
 582     return Ok; \
 583 } while (0);
 584
 585 #define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
 586     for (y=0; y<height; y++) \
 587         for (x=0; x<width; x++) { \
 588             BYTE r, g, b, a; \
 589             getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
 590             setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
 591         } \
 592     return Ok; \
 593 } while (0);
 594
 595 #define convert_rgb_to_indexed(getpixel_function, setpixel_function) do { \
 596     for (y=0; y<height; y++) \
 597         for (x=0; x<width; x++) { \
 598             BYTE r, g, b, a; \
 599             getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
 600             setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x, palette); \
 601         } \
 602     return Ok; \
 603 } while (0);
 604
 605     switch (src_format)
 606     {
 607     case PixelFormat1bppIndexed:
 608         switch (dst_format)
 609         {
 610         case PixelFormat16bppGrayScale:
 611             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppGrayScale);
 612         case PixelFormat16bppRGB555:
 613             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB555);
 614         case PixelFormat16bppRGB565:
 615             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppRGB565);
 616         case PixelFormat16bppARGB1555:
 617             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_16bppARGB1555);
 618         case PixelFormat24bppRGB:
 619             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_24bppRGB);
 620         case PixelFormat32bppRGB:
 621             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppRGB);
 622         case PixelFormat32bppARGB:
 623             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppARGB);
 624         case PixelFormat32bppPARGB:
 625             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_32bppPARGB);
 626         case PixelFormat48bppRGB:
 627             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_48bppRGB);
 628         case PixelFormat64bppARGB:
 629             convert_indexed_to_rgb(getpixel_1bppIndexed, setpixel_64bppARGB);
 630         default:
 631             break;
 632         }
 633         break;
 634     case PixelFormat4bppIndexed:
 635         switch (dst_format)
 636         {
 637         case PixelFormat16bppGrayScale:
 638             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppGrayScale);
 639         case PixelFormat16bppRGB555:
 640             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB555);
 641         case PixelFormat16bppRGB565:
 642             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppRGB565);
 643         case PixelFormat16bppARGB1555:
 644             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_16bppARGB1555);
 645         case PixelFormat24bppRGB:
 646             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_24bppRGB);
 647         case PixelFormat32bppRGB:
 648             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppRGB);
 649         case PixelFormat32bppARGB:
 650             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppARGB);
 651         case PixelFormat32bppPARGB:
 652             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_32bppPARGB);
 653         case PixelFormat48bppRGB:
 654             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_48bppRGB);
 655         case PixelFormat64bppARGB:
 656             convert_indexed_to_rgb(getpixel_4bppIndexed, setpixel_64bppARGB);
 657         default:
 658             break;
 659         }
 660         break;
 661     case PixelFormat8bppIndexed:
 662         switch (dst_format)
 663         {
 664         case PixelFormat16bppGrayScale:
 665             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppGrayScale);
 666         case PixelFormat16bppRGB555:
 667             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB555);
 668         case PixelFormat16bppRGB565:
 669             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppRGB565);
 670         case PixelFormat16bppARGB1555:
 671             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_16bppARGB1555);
 672         case PixelFormat24bppRGB:
 673             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_24bppRGB);
 674         case PixelFormat32bppRGB:
 675             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppRGB);
 676         case PixelFormat32bppARGB:
 677             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppARGB);
 678         case PixelFormat32bppPARGB:
 679             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_32bppPARGB);
 680         case PixelFormat48bppRGB:
 681             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_48bppRGB);
 682         case PixelFormat64bppARGB:
 683             convert_indexed_to_rgb(getpixel_8bppIndexed, setpixel_64bppARGB);
 684         default:
 685             break;
 686         }
 687         break;
 688     case PixelFormat16bppGrayScale:
 689         switch (dst_format)
 690         {
 691         case PixelFormat1bppIndexed:
 692             convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_1bppIndexed);
 693         case PixelFormat8bppIndexed:
 694             convert_rgb_to_indexed(getpixel_16bppGrayScale, setpixel_8bppIndexed);
 695         case PixelFormat16bppRGB555:
 696             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB555);
 697         case PixelFormat16bppRGB565:
 698             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppRGB565);
 699         case PixelFormat16bppARGB1555:
 700             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_16bppARGB1555);
 701         case PixelFormat24bppRGB:
 702             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_24bppRGB);
 703         case PixelFormat32bppRGB:
 704             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppRGB);
 705         case PixelFormat32bppARGB:
 706             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppARGB);
 707         case PixelFormat32bppPARGB:
 708             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_32bppPARGB);
 709         case PixelFormat48bppRGB:
 710             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_48bppRGB);
 711         case PixelFormat64bppARGB:
 712             convert_rgb_to_rgb(getpixel_16bppGrayScale, setpixel_64bppARGB);
 713         default:
 714             break;
 715         }
 716         break;
 717     case PixelFormat16bppRGB555:
 718         switch (dst_format)
 719         {
 720         case PixelFormat1bppIndexed:
 721             convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_1bppIndexed);
 722         case PixelFormat8bppIndexed:
 723             convert_rgb_to_indexed(getpixel_16bppRGB555, setpixel_8bppIndexed);
 724         case PixelFormat16bppGrayScale:
 725             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppGrayScale);
 726         case PixelFormat16bppRGB565:
 727             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppRGB565);
 728         case PixelFormat16bppARGB1555:
 729             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_16bppARGB1555);
 730         case PixelFormat24bppRGB:
 731             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_24bppRGB);
 732         case PixelFormat32bppRGB:
 733             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppRGB);
 734         case PixelFormat32bppARGB:
 735             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppARGB);
 736         case PixelFormat32bppPARGB:
 737             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_32bppPARGB);
 738         case PixelFormat48bppRGB:
 739             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_48bppRGB);
 740         case PixelFormat64bppARGB:
 741             convert_rgb_to_rgb(getpixel_16bppRGB555, setpixel_64bppARGB);
 742         default:
 743             break;
 744         }
 745         break;
 746     case PixelFormat16bppRGB565:
 747         switch (dst_format)
 748         {
 749         case PixelFormat1bppIndexed:
 750             convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_1bppIndexed);
 751         case PixelFormat8bppIndexed:
 752             convert_rgb_to_indexed(getpixel_16bppRGB565, setpixel_8bppIndexed);
 753         case PixelFormat16bppGrayScale:
 754             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppGrayScale);
 755         case PixelFormat16bppRGB555:
 756             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppRGB555);
 757         case PixelFormat16bppARGB1555:
 758             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_16bppARGB1555);
 759         case PixelFormat24bppRGB:
 760             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_24bppRGB);
 761         case PixelFormat32bppRGB:
 762             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppRGB);
 763         case PixelFormat32bppARGB:
 764             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppARGB);
 765         case PixelFormat32bppPARGB:
 766             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_32bppPARGB);
 767         case PixelFormat48bppRGB:
 768             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_48bppRGB);
 769         case PixelFormat64bppARGB:
 770             convert_rgb_to_rgb(getpixel_16bppRGB565, setpixel_64bppARGB);
 771         default:
 772             break;
 773         }
 774         break;
 775     case PixelFormat16bppARGB1555:
 776         switch (dst_format)
 777         {
 778         case PixelFormat1bppIndexed:
 779             convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_1bppIndexed);
 780         case PixelFormat8bppIndexed:
 781             convert_rgb_to_indexed(getpixel_16bppARGB1555, setpixel_8bppIndexed);
 782         case PixelFormat16bppGrayScale:
 783             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppGrayScale);
 784         case PixelFormat16bppRGB555:
 785             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB555);
 786         case PixelFormat16bppRGB565:
 787             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_16bppRGB565);
 788         case PixelFormat24bppRGB:
 789             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_24bppRGB);
 790         case PixelFormat32bppRGB:
 791             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppRGB);
 792         case PixelFormat32bppARGB:
 793             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppARGB);
 794         case PixelFormat32bppPARGB:
 795             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_32bppPARGB);
 796         case PixelFormat48bppRGB:
 797             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_48bppRGB);
 798         case PixelFormat64bppARGB:
 799             convert_rgb_to_rgb(getpixel_16bppARGB1555, setpixel_64bppARGB);
 800         default:
 801             break;
 802         }
 803         break;
 804     case PixelFormat24bppRGB:
 805         switch (dst_format)
 806         {
 807         case PixelFormat1bppIndexed:
 808             convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_1bppIndexed);
 809         case PixelFormat8bppIndexed:
 810             convert_rgb_to_indexed(getpixel_24bppRGB, setpixel_8bppIndexed);
 811         case PixelFormat16bppGrayScale:
 812             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppGrayScale);
 813         case PixelFormat16bppRGB555:
 814             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB555);
 815         case PixelFormat16bppRGB565:
 816             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppRGB565);
 817         case PixelFormat16bppARGB1555:
 818             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_16bppARGB1555);
 819         case PixelFormat32bppRGB:
 820             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppRGB);
 821         case PixelFormat32bppARGB:
 822             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppARGB);
 823         case PixelFormat32bppPARGB:
 824             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_32bppPARGB);
 825         case PixelFormat48bppRGB:
 826             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_48bppRGB);
 827         case PixelFormat64bppARGB:
 828             convert_rgb_to_rgb(getpixel_24bppRGB, setpixel_64bppARGB);
 829         default:
 830             break;
 831         }
 832         break;
 833     case PixelFormat32bppRGB:
 834         switch (dst_format)
 835         {
 836         case PixelFormat1bppIndexed:
 837             convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_1bppIndexed);
 838         case PixelFormat8bppIndexed:
 839             convert_rgb_to_indexed(getpixel_32bppRGB, setpixel_8bppIndexed);
 840         case PixelFormat16bppGrayScale:
 841             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppGrayScale);
 842         case PixelFormat16bppRGB555:
 843             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB555);
 844         case PixelFormat16bppRGB565:
 845             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppRGB565);
 846         case PixelFormat16bppARGB1555:
 847             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_16bppARGB1555);
 848         case PixelFormat24bppRGB:
 849             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_24bppRGB);
 850         case PixelFormat32bppARGB:
 851             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppARGB);
 852         case PixelFormat32bppPARGB:
 853             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_32bppPARGB);
 854         case PixelFormat48bppRGB:
 855             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_48bppRGB);
 856         case PixelFormat64bppARGB:
 857             convert_rgb_to_rgb(getpixel_32bppRGB, setpixel_64bppARGB);
 858         default:
 859             break;
 860         }
 861         break;
 862     case PixelFormat32bppARGB:
 863         switch (dst_format)
 864         {
 865         case PixelFormat1bppIndexed:
 866             convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_1bppIndexed);
 867         case PixelFormat8bppIndexed:
 868             convert_rgb_to_indexed(getpixel_32bppARGB, setpixel_8bppIndexed);
 869         case PixelFormat16bppGrayScale:
 870             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppGrayScale);
 871         case PixelFormat16bppRGB555:
 872             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB555);
 873         case PixelFormat16bppRGB565:
 874             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppRGB565);
 875         case PixelFormat16bppARGB1555:
 876             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_16bppARGB1555);
 877         case PixelFormat24bppRGB:
 878             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_24bppRGB);
 879         case PixelFormat32bppPARGB:
 880             convert_32bppARGB_to_32bppPARGB(width, height, dst_bits, dst_stride, src_bits, src_stride);
 881             return Ok;
 882         case PixelFormat48bppRGB:
 883             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_48bppRGB);
 884         case PixelFormat64bppARGB:
 885             convert_rgb_to_rgb(getpixel_32bppARGB, setpixel_64bppARGB);
 886         default:
 887             break;
 888         }
 889         break;
 890     case PixelFormat32bppPARGB:
 891         switch (dst_format)
 892         {
 893         case PixelFormat1bppIndexed:
 894             convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_1bppIndexed);
 895         case PixelFormat8bppIndexed:
 896             convert_rgb_to_indexed(getpixel_32bppPARGB, setpixel_8bppIndexed);
 897         case PixelFormat16bppGrayScale:
 898             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppGrayScale);
 899         case PixelFormat16bppRGB555:
 900             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB555);
 901         case PixelFormat16bppRGB565:
 902             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppRGB565);
 903         case PixelFormat16bppARGB1555:
 904             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_16bppARGB1555);
 905         case PixelFormat24bppRGB:
 906             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_24bppRGB);
 907         case PixelFormat32bppRGB:
 908             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppRGB);
 909         case PixelFormat32bppARGB:
 910             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_32bppARGB);
 911         case PixelFormat48bppRGB:
 912             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_48bppRGB);
 913         case PixelFormat64bppARGB:
 914             convert_rgb_to_rgb(getpixel_32bppPARGB, setpixel_64bppARGB);
 915         default:
 916             break;
 917         }
 918         break;
 919     case PixelFormat48bppRGB:
 920         switch (dst_format)
 921         {
 922         case PixelFormat1bppIndexed:
 923             convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_1bppIndexed);
 924         case PixelFormat8bppIndexed:
 925             convert_rgb_to_indexed(getpixel_48bppRGB, setpixel_8bppIndexed);
 926         case PixelFormat16bppGrayScale:
 927             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppGrayScale);
 928         case PixelFormat16bppRGB555:
 929             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB555);
 930         case PixelFormat16bppRGB565:
 931             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppRGB565);
 932         case PixelFormat16bppARGB1555:
 933             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_16bppARGB1555);
 934         case PixelFormat24bppRGB:
 935             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_24bppRGB);
 936         case PixelFormat32bppRGB:
 937             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppRGB);
 938         case PixelFormat32bppARGB:
 939             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppARGB);
 940         case PixelFormat32bppPARGB:
 941             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_32bppPARGB);
 942         case PixelFormat64bppARGB:
 943             convert_rgb_to_rgb(getpixel_48bppRGB, setpixel_64bppARGB);
 944         default:
 945             break;
 946         }
 947         break;
 948     case PixelFormat64bppARGB:
 949         switch (dst_format)
 950         {
 951         case PixelFormat1bppIndexed:
 952             convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_1bppIndexed);
 953         case PixelFormat8bppIndexed:
 954             convert_rgb_to_indexed(getpixel_64bppARGB, setpixel_8bppIndexed);
 955         case PixelFormat16bppGrayScale:
 956             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppGrayScale);
 957         case PixelFormat16bppRGB555:
 958             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB555);
 959         case PixelFormat16bppRGB565:
 960             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppRGB565);
 961         case PixelFormat16bppARGB1555:
 962             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_16bppARGB1555);
 963         case PixelFormat24bppRGB:
 964             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_24bppRGB);
 965         case PixelFormat32bppRGB:
 966             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppRGB);
 967         case PixelFormat32bppARGB:
 968             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppARGB);
 969         case PixelFormat32bppPARGB:
 970             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_32bppPARGB);
 971         case PixelFormat48bppRGB:
 972             convert_rgb_to_rgb(getpixel_64bppARGB, setpixel_48bppRGB);
 973         default:
 974             break;
 975         }
 976         break;
 977     case PixelFormat64bppPARGB:
 978         switch (dst_format)
 979         {
 980         case PixelFormat1bppIndexed:
 981             convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_1bppIndexed);
 982         case PixelFormat8bppIndexed:
 983             convert_rgb_to_indexed(getpixel_64bppPARGB, setpixel_8bppIndexed);
 984         case PixelFormat16bppGrayScale:
 985             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppGrayScale);
 986         case PixelFormat16bppRGB555:
 987             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB555);
 988         case PixelFormat16bppRGB565:
 989             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppRGB565);
 990         case PixelFormat16bppARGB1555:
 991             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_16bppARGB1555);
 992         case PixelFormat24bppRGB:
 993             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_24bppRGB);
 994         case PixelFormat32bppRGB:
 995             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppRGB);
 996         case PixelFormat32bppARGB:
 997             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppARGB);
 998         case PixelFormat32bppPARGB:
 999             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_32bppPARGB);
1000         case PixelFormat48bppRGB:
1001             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_48bppRGB);
1002         case PixelFormat64bppARGB:
1003             convert_rgb_to_rgb(getpixel_64bppPARGB, setpixel_64bppARGB);
1004         default:
1005             break;
1006         }
1007         break;
1008     default:
1009         break;
1010     }
1011
1012 #undef convert_indexed_to_rgb
1013 #undef convert_rgb_to_rgb
1014
1015     return NotImplemented;
1016 }
1017
1018 /* This function returns a pointer to an array of pixels that represents the
1019  * bitmap. The *entire* bitmap is locked according to the lock mode specified by
1020  * flags.  It is correct behavior that a user who calls this function with write
1021  * privileges can write to the whole bitmap (not just the area in rect).
1022  *
1023  * FIXME: only used portion of format is bits per pixel. */
1024 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
1025     UINT flags, PixelFormat format, BitmapData* lockeddata)
1026 {
1027     INT bitspp = PIXELFORMATBPP(format);
1028     GpRect act_rect; /* actual rect to be used */
1029     GpStatus stat;
1030     BOOL unlock;
1031
1032     TRACE("%p %p %d 0x%x %p\n", bitmap, rect, flags, format, lockeddata);
1033
1034     if(!lockeddata || !bitmap)
1035         return InvalidParameter;
1036     if(!image_lock(&bitmap->image, &unlock))
1037         return ObjectBusy;
1038
1039     if(rect){
1040         if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
1041           (rect->Y + rect->Height > bitmap->height) || !flags)
1042         {
1043             image_unlock(&bitmap->image, unlock);
1044             return InvalidParameter;
1045         }
1046
1047         act_rect = *rect;
1048     }
1049     else{
1050         act_rect.X = act_rect.Y = 0;
1051         act_rect.Width  = bitmap->width;
1052         act_rect.Height = bitmap->height;
1053     }
1054
1055     if(bitmap->lockmode)
1056     {
1057         WARN("bitmap is already locked and cannot be locked again\n");
1058         image_unlock(&bitmap->image, unlock);
1059         return WrongState;
1060     }
1061
1062     if (bitmap->bits && bitmap->format == format && !(flags & ImageLockModeUserInputBuf))
1063     {
1064         /* no conversion is necessary; just use the bits directly */
1065         lockeddata->Width = act_rect.Width;
1066         lockeddata->Height = act_rect.Height;
1067         lockeddata->PixelFormat = format;
1068         lockeddata->Reserved = flags;
1069         lockeddata->Stride = bitmap->stride;
1070         lockeddata->Scan0 = bitmap->bits + (bitspp / 8) * act_rect.X +
1071                             bitmap->stride * act_rect.Y;
1072
1073         bitmap->lockmode = flags | ImageLockModeRead;
1074
1075         image_unlock(&bitmap->image, unlock);
1076         return Ok;
1077     }
1078
1079     /* Make sure we can convert to the requested format. */
1080     if (flags & ImageLockModeRead)
1081     {
1082         stat = convert_pixels(0, 0, 0, NULL, format, 0, NULL, bitmap->format, NULL);
1083         if (stat == NotImplemented)
1084         {
1085             FIXME("cannot read bitmap from %x to %x\n", bitmap->format, format);
1086             image_unlock(&bitmap->image, unlock);
1087             return NotImplemented;
1088         }
1089     }
1090
1091     /* If we're opening for writing, make sure we'll be able to write back in
1092      * the original format. */
1093     if (flags & ImageLockModeWrite)
1094     {
1095         stat = convert_pixels(0, 0, 0, NULL, bitmap->format, 0, NULL, format, NULL);
1096         if (stat == NotImplemented)
1097         {
1098             FIXME("cannot write bitmap from %x to %x\n", format, bitmap->format);
1099             image_unlock(&bitmap->image, unlock);
1100             return NotImplemented;
1101         }
1102     }
1103
1104     lockeddata->Width  = act_rect.Width;
1105     lockeddata->Height = act_rect.Height;
1106     lockeddata->PixelFormat = format;
1107     lockeddata->Reserved = flags;
1108
1109     if(!(flags & ImageLockModeUserInputBuf))
1110     {
1111         lockeddata->Stride = (((act_rect.Width * bitspp + 7) / 8) + 3) & ~3;
1112
1113         bitmap->bitmapbits = heap_alloc_zero(lockeddata->Stride * act_rect.Height);
1114
1115         if (!bitmap->bitmapbits)
1116         {
1117             image_unlock(&bitmap->image, unlock);
1118             return OutOfMemory;
1119         }
1120
1121         lockeddata->Scan0  = bitmap->bitmapbits;
1122     }
1123
1124     if (flags & ImageLockModeRead)
1125     {
1126         static BOOL fixme = FALSE;
1127
1128         if (!fixme && (PIXELFORMATBPP(bitmap->format) * act_rect.X) % 8 != 0)
1129         {
1130             FIXME("Cannot copy rows that don't start at a whole byte.\n");
1131             fixme = TRUE;
1132         }
1133
1134         stat = convert_pixels(act_rect.Width, act_rect.Height,
1135             lockeddata->Stride, lockeddata->Scan0, format,
1136             bitmap->stride,
1137             bitmap->bits + bitmap->stride * act_rect.Y + PIXELFORMATBPP(bitmap->format) * act_rect.X / 8,
1138             bitmap->format, bitmap->image.palette);
1139
1140         if (stat != Ok)
1141         {
1142             heap_free(bitmap->bitmapbits);
1143             bitmap->bitmapbits = NULL;
1144             image_unlock(&bitmap->image, unlock);
1145             return stat;
1146         }
1147     }
1148
1149     bitmap->lockmode = flags | ImageLockModeRead;
1150     bitmap->lockx = act_rect.X;
1151     bitmap->locky = act_rect.Y;
1152
1153     image_unlock(&bitmap->image, unlock);
1154     return Ok;
1155 }
1156
1157 GpStatus WINGDIPAPI GdipBitmapSetResolution(GpBitmap* bitmap, REAL xdpi, REAL ydpi)
1158 {
1159     TRACE("(%p, %.2f, %.2f)\n", bitmap, xdpi, ydpi);
1160
1161     if (!bitmap || xdpi == 0.0 || ydpi == 0.0)
1162         return InvalidParameter;
1163
1164     bitmap->image.xres = xdpi;
1165     bitmap->image.yres = ydpi;
1166
1167     return Ok;
1168 }
1169
1170 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
1171     BitmapData* lockeddata)
1172 {
1173     GpStatus stat;
1174     static BOOL fixme = FALSE;
1175     BOOL unlock;
1176
1177     TRACE("(%p,%p)\n", bitmap, lockeddata);
1178
1179     if(!bitmap || !lockeddata)
1180         return InvalidParameter;
1181     if(!image_lock(&bitmap->image, &unlock))
1182         return ObjectBusy;
1183
1184     if(!bitmap->lockmode)
1185     {
1186         image_unlock(&bitmap->image, unlock);
1187         return WrongState;
1188     }
1189
1190     if(!(lockeddata->Reserved & ImageLockModeWrite)){
1191         bitmap->lockmode = 0;
1192         heap_free(bitmap->bitmapbits);
1193         bitmap->bitmapbits = NULL;
1194         image_unlock(&bitmap->image, unlock);
1195         return Ok;
1196     }
1197
1198     if (!bitmap->bitmapbits && !(lockeddata->Reserved & ImageLockModeUserInputBuf))
1199     {
1200         /* we passed a direct reference; no need to do anything */
1201         bitmap->lockmode = 0;
1202         image_unlock(&bitmap->image, unlock);
1203         return Ok;
1204     }
1205
1206     if (!fixme && (PIXELFORMATBPP(bitmap->format) * bitmap->lockx) % 8 != 0)
1207     {
1208         FIXME("Cannot copy rows that don't start at a whole byte.\n");
1209         fixme = TRUE;
1210     }
1211
1212     stat = convert_pixels(lockeddata->Width, lockeddata->Height,
1213         bitmap->stride,
1214         bitmap->bits + bitmap->stride * bitmap->locky + PIXELFORMATBPP(bitmap->format) * bitmap->lockx / 8,
1215         bitmap->format,
1216         lockeddata->Stride, lockeddata->Scan0, lockeddata->PixelFormat, NULL);
1217
1218     if (stat != Ok)
1219     {
1220         ERR("failed to convert pixels; this should never happen\n");
1221     }
1222
1223     heap_free(bitmap->bitmapbits);
1224     bitmap->bitmapbits = NULL;
1225     bitmap->lockmode = 0;
1226
1227     image_unlock(&bitmap->image, unlock);
1228     return stat;
1229 }
1230
1231 GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height,
1232     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1233 {
1234     Rect area;
1235     GpStatus stat;
1236
1237     TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1238
1239     if (!srcBitmap || !dstBitmap || srcBitmap->image.type != ImageTypeBitmap ||
1240         x < 0 || y < 0 ||
1241         x + width > srcBitmap->width || y + height > srcBitmap->height)
1242     {
1243         TRACE("<-- InvalidParameter\n");
1244         return InvalidParameter;
1245     }
1246
1247     if (format == PixelFormatDontCare)
1248         format = srcBitmap->format;
1249
1250     area.X = gdip_round(x);
1251     area.Y = gdip_round(y);
1252     area.Width = gdip_round(width);
1253     area.Height = gdip_round(height);
1254
1255     stat = GdipCreateBitmapFromScan0(area.Width, area.Height, 0, format, NULL, dstBitmap);
1256     if (stat == Ok)
1257     {
1258         stat = convert_pixels(area.Width, area.Height, (*dstBitmap)->stride, (*dstBitmap)->bits, (*dstBitmap)->format,
1259                               srcBitmap->stride,
1260                               srcBitmap->bits + srcBitmap->stride * area.Y + PIXELFORMATBPP(srcBitmap->format) * area.X / 8,
1261                               srcBitmap->format, srcBitmap->image.palette);
1262
1263         if (stat == Ok && srcBitmap->image.palette)
1264         {
1265             ColorPalette *src_palette, *dst_palette;
1266
1267             src_palette = srcBitmap->image.palette;
1268
1269             dst_palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * src_palette->Count);
1270
1271             if (dst_palette)
1272             {
1273                 dst_palette->Flags = src_palette->Flags;
1274                 dst_palette->Count = src_palette->Count;
1275                 memcpy(dst_palette->Entries, src_palette->Entries, sizeof(ARGB) * src_palette->Count);
1276
1277                 heap_free((*dstBitmap)->image.palette);
1278                 (*dstBitmap)->image.palette = dst_palette;
1279             }
1280             else
1281                 stat = OutOfMemory;
1282         }
1283
1284         if (stat != Ok)
1285             GdipDisposeImage(&(*dstBitmap)->image);
1286     }
1287
1288     if (stat != Ok)
1289         *dstBitmap = NULL;
1290
1291     return stat;
1292 }
1293
1294 GpStatus WINGDIPAPI GdipCloneBitmapAreaI(INT x, INT y, INT width, INT height,
1295     PixelFormat format, GpBitmap* srcBitmap, GpBitmap** dstBitmap)
1296 {
1297     TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x, y, width, height, format, srcBitmap, dstBitmap);
1298
1299     return GdipCloneBitmapArea(x, y, width, height, format, srcBitmap, dstBitmap);
1300 }
1301
1302 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
1303 {
1304     TRACE("%p, %p\n", image, cloneImage);
1305
1306     if (!image || !cloneImage)
1307         return InvalidParameter;
1308
1309     if (image->type == ImageTypeBitmap)
1310     {
1311         GpBitmap *bitmap = (GpBitmap *)image;
1312
1313         return GdipCloneBitmapAreaI(0, 0, bitmap->width, bitmap->height,
1314                                     bitmap->format, bitmap, (GpBitmap **)cloneImage);
1315     }
1316     else if (image->type == ImageTypeMetafile && ((GpMetafile*)image)->hemf)
1317     {
1318         GpMetafile *result, *metafile;
1319
1320         metafile = (GpMetafile*)image;
1321
1322         result = heap_alloc_zero(sizeof(*result));
1323         if (!result)
1324             return OutOfMemory;
1325
1326         result->image.type = ImageTypeMetafile;
1327         result->image.format = image->format;
1328         result->image.flags = image->flags;
1329         result->image.frame_count = 1;
1330         result->image.xres = image->xres;
1331         result->image.yres = image->yres;
1332         result->bounds = metafile->bounds;
1333         result->unit = metafile->unit;
1334         result->metafile_type = metafile->metafile_type;
1335         result->hemf = CopyEnhMetaFileW(metafile->hemf, NULL);
1336         list_init(&result->containers);
1337
1338         if (!result->hemf)
1339         {
1340             heap_free(result);
1341             return OutOfMemory;
1342         }
1343
1344         *cloneImage = &result->image;
1345         return Ok;
1346     }
1347     else
1348     {
1349         WARN("GpImage with no image data (metafile in wrong state?)\n");
1350         return InvalidParameter;
1351     }
1352 }
1353
1354 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
1355     GpBitmap **bitmap)
1356 {
1357     GpStatus stat;
1358     IStream *stream;
1359
1360     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1361
1362     if(!filename || !bitmap)
1363         return InvalidParameter;
1364
1365     *bitmap = NULL;
1366
1367     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
1368
1369     if(stat != Ok)
1370         return stat;
1371
1372     stat = GdipCreateBitmapFromStream(stream, bitmap);
1373
1374     IStream_Release(stream);
1375
1376     return stat;
1377 }
1378
1379 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
1380                                                VOID *bits, GpBitmap **bitmap)
1381 {
1382     DWORD height, stride;
1383     PixelFormat format;
1384
1385     FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
1386
1387     if (!info || !bits || !bitmap)
1388         return InvalidParameter;
1389
1390     height = abs(info->bmiHeader.biHeight);
1391     stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
1392
1393     if(info->bmiHeader.biHeight > 0) /* bottom-up */
1394     {
1395         bits = (BYTE*)bits + (height - 1) * stride;
1396         stride = -stride;
1397     }
1398
1399     switch(info->bmiHeader.biBitCount) {
1400     case 1:
1401         format = PixelFormat1bppIndexed;
1402         break;
1403     case 4:
1404         format = PixelFormat4bppIndexed;
1405         break;
1406     case 8:
1407         format = PixelFormat8bppIndexed;
1408         break;
1409     case 16:
1410         format = PixelFormat16bppRGB555;
1411         break;
1412     case 24:
1413         format = PixelFormat24bppRGB;
1414         break;
1415     case 32:
1416         format = PixelFormat32bppRGB;
1417         break;
1418     default:
1419         FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
1420         *bitmap = NULL;
1421         return InvalidParameter;
1422     }
1423
1424     return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
1425                                      bits, bitmap);
1426
1427 }
1428
1429 /* FIXME: no icm */
1430 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
1431     GpBitmap **bitmap)
1432 {
1433     TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
1434
1435     return GdipCreateBitmapFromFile(filename, bitmap);
1436 }
1437
1438 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
1439     GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
1440 {
1441     HBITMAP hbm;
1442     GpStatus stat = InvalidParameter;
1443
1444     TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
1445
1446     if(!lpBitmapName || !bitmap)
1447         return InvalidParameter;
1448
1449     /* load DIB */
1450     hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
1451                      LR_CREATEDIBSECTION);
1452
1453     if(hbm){
1454         stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
1455         DeleteObject(hbm);
1456     }
1457
1458     return stat;
1459 }
1460
1461 static inline DWORD blend_argb_no_bkgnd_alpha(DWORD src, DWORD bkgnd)
1462 {
1463     BYTE b = (BYTE)src;
1464     BYTE g = (BYTE)(src >> 8);
1465     BYTE r = (BYTE)(src >> 16);
1466     DWORD alpha  = (BYTE)(src >> 24);
1467     return ((b     + ((BYTE)bkgnd         * (255 - alpha) + 127) / 255) |
1468             (g     + ((BYTE)(bkgnd >> 8)  * (255 - alpha) + 127) / 255) << 8 |
1469             (r     + ((BYTE)(bkgnd >> 16) * (255 - alpha) + 127) / 255) << 16 |
1470             (alpha << 24));
1471 }
1472
1473 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
1474     HBITMAP* hbmReturn, ARGB background)
1475 {
1476     GpStatus stat;
1477     HBITMAP result;
1478     UINT width, height;
1479     BITMAPINFOHEADER bih;
1480     LPBYTE bits;
1481     BOOL unlock;
1482
1483     TRACE("(%p,%p,%x)\n", bitmap, hbmReturn, background);
1484
1485     if (!bitmap || !hbmReturn) return InvalidParameter;
1486     if (!image_lock(&bitmap->image, &unlock)) return ObjectBusy;
1487
1488     GdipGetImageWidth(&bitmap->image, &width);
1489     GdipGetImageHeight(&bitmap->image, &height);
1490
1491     bih.biSize = sizeof(bih);
1492     bih.biWidth = width;
1493     bih.biHeight = height;
1494     bih.biPlanes = 1;
1495     bih.biBitCount = 32;
1496     bih.biCompression = BI_RGB;
1497     bih.biSizeImage = 0;
1498     bih.biXPelsPerMeter = 0;
1499     bih.biYPelsPerMeter = 0;
1500     bih.biClrUsed = 0;
1501     bih.biClrImportant = 0;
1502
1503     result = CreateDIBSection(0, (BITMAPINFO*)&bih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1504     if (!result)
1505     {
1506         image_unlock(&bitmap->image, unlock);
1507         return GenericError;
1508     }
1509
1510     stat = convert_pixels(width, height, -width*4,
1511             bits + (width * 4 * (height - 1)), PixelFormat32bppPARGB,
1512             bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette);
1513     if (stat != Ok)
1514     {
1515         DeleteObject(result);
1516         image_unlock(&bitmap->image, unlock);
1517         return stat;
1518     }
1519
1520     if (background & 0xffffff)
1521     {
1522         DWORD *ptr;
1523         UINT i;
1524         for (ptr = (DWORD*)bits, i = 0; i < width * height; ptr++, i++)
1525         {
1526             if ((*ptr & 0xff000000) == 0xff000000) continue;
1527             *ptr = blend_argb_no_bkgnd_alpha(*ptr, background);
1528         }
1529     }
1530
1531     *hbmReturn = result;
1532     image_unlock(&bitmap->image, unlock);
1533     return Ok;
1534 }
1535
1536 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
1537     GpGraphics* target, GpBitmap** bitmap)
1538 {
1539     GpStatus ret;
1540
1541     TRACE("(%d, %d, %p, %p)\n", width, height, target, bitmap);
1542
1543     if(!target || !bitmap)
1544         return InvalidParameter;
1545
1546     ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
1547                                     NULL, bitmap);
1548
1549     if (ret == Ok)
1550     {
1551         GdipGetDpiX(target, &(*bitmap)->image.xres);
1552         GdipGetDpiY(target, &(*bitmap)->image.yres);
1553     }
1554
1555     return ret;
1556 }
1557
1558 GpStatus WINGDIPAPI GdipCreateBitmapFromHICON(HICON hicon, GpBitmap** bitmap)
1559 {
1560     GpStatus stat;
1561     ICONINFO iinfo;
1562     BITMAP bm;
1563     int ret;
1564     UINT width, height, stride;
1565     GpRect rect;
1566     BitmapData lockeddata;
1567     HDC screendc;
1568     BOOL has_alpha;
1569     int x, y;
1570     BITMAPINFOHEADER bih;
1571     DWORD *src;
1572     BYTE *dst_row;
1573     DWORD *dst;
1574
1575     TRACE("%p, %p\n", hicon, bitmap);
1576
1577     if(!bitmap || !GetIconInfo(hicon, &iinfo))
1578         return InvalidParameter;
1579
1580     /* get the size of the icon */
1581     ret = GetObjectA(iinfo.hbmColor ? iinfo.hbmColor : iinfo.hbmMask, sizeof(bm), &bm);
1582     if (ret == 0) {
1583         DeleteObject(iinfo.hbmColor);
1584         DeleteObject(iinfo.hbmMask);
1585         return GenericError;
1586     }
1587
1588     width = bm.bmWidth;
1589     height = iinfo.hbmColor ? abs(bm.bmHeight) : abs(bm.bmHeight) / 2;
1590     stride = width * 4;
1591
1592     stat = GdipCreateBitmapFromScan0(width, height, stride, PixelFormat32bppARGB, NULL, bitmap);
1593     if (stat != Ok) {
1594         DeleteObject(iinfo.hbmColor);
1595         DeleteObject(iinfo.hbmMask);
1596         return stat;
1597     }
1598
1599     rect.X = 0;
1600     rect.Y = 0;
1601     rect.Width = width;
1602     rect.Height = height;
1603
1604     stat = GdipBitmapLockBits(*bitmap, &rect, ImageLockModeWrite, PixelFormat32bppARGB, &lockeddata);
1605     if (stat != Ok) {
1606         DeleteObject(iinfo.hbmColor);
1607         DeleteObject(iinfo.hbmMask);
1608         GdipDisposeImage(&(*bitmap)->image);
1609         return stat;
1610     }
1611
1612     bih.biSize = sizeof(bih);
1613     bih.biWidth = width;
1614     bih.biHeight = iinfo.hbmColor ? -height: -height * 2;
1615     bih.biPlanes = 1;
1616     bih.biBitCount = 32;
1617     bih.biCompression = BI_RGB;
1618     bih.biSizeImage = 0;
1619     bih.biXPelsPerMeter = 0;
1620     bih.biYPelsPerMeter = 0;
1621     bih.biClrUsed = 0;
1622     bih.biClrImportant = 0;
1623
1624     screendc = CreateCompatibleDC(0);
1625     if (iinfo.hbmColor)
1626     {
1627         GetDIBits(screendc, iinfo.hbmColor, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1628
1629         if (bm.bmBitsPixel == 32)
1630         {
1631             has_alpha = FALSE;
1632
1633             /* If any pixel has a non-zero alpha, ignore hbmMask */
1634             src = (DWORD*)lockeddata.Scan0;
1635             for (x=0; x<width && !has_alpha; x++)
1636                 for (y=0; y<height && !has_alpha; y++)
1637                     if ((*src++ & 0xff000000) != 0)
1638                         has_alpha = TRUE;
1639         }
1640         else has_alpha = FALSE;
1641     }
1642     else
1643     {
1644         GetDIBits(screendc, iinfo.hbmMask, 0, height, lockeddata.Scan0, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1645         has_alpha = FALSE;
1646     }
1647
1648     if (!has_alpha)
1649     {
1650         if (iinfo.hbmMask)
1651         {
1652             BYTE *bits = heap_alloc(height * stride);
1653
1654             /* read alpha data from the mask */
1655             if (iinfo.hbmColor)
1656                 GetDIBits(screendc, iinfo.hbmMask, 0, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1657             else
1658                 GetDIBits(screendc, iinfo.hbmMask, height, height, bits, (BITMAPINFO*)&bih, DIB_RGB_COLORS);
1659
1660             src = (DWORD*)bits;
1661             dst_row = lockeddata.Scan0;
1662             for (y=0; y<height; y++)
1663             {
1664                 dst = (DWORD*)dst_row;
1665                 for (x=0; x<height; x++)
1666                 {
1667                     DWORD src_value = *src++;
1668                     if (src_value)
1669                         *dst++ = 0;
1670                     else
1671                         *dst++ |= 0xff000000;
1672                 }
1673                 dst_row += lockeddata.Stride;
1674             }
1675
1676             heap_free(bits);
1677         }
1678         else
1679         {
1680             /* set constant alpha of 255 */
1681             dst_row = lockeddata.Scan0;
1682             for (y=0; y<height; y++)
1683             {
1684                 dst = (DWORD*)dst_row;
1685                 for (x=0; x<height; x++)
1686                     *dst++ |= 0xff000000;
1687                 dst_row += lockeddata.Stride;
1688             }
1689         }
1690     }
1691
1692     DeleteDC(screendc);
1693
1694     DeleteObject(iinfo.hbmColor);
1695     DeleteObject(iinfo.hbmMask);
1696
1697     GdipBitmapUnlockBits(*bitmap, &lockeddata);
1698
1699     return Ok;
1700 }
1701
1702 static void generate_halftone_palette(ARGB *entries, UINT count)
1703 {
1704     static const BYTE halftone_values[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1705     UINT i;
1706
1707     for (i=0; i<8 && i<count; i++)
1708     {
1709         entries[i] = 0xff000000;
1710         if (i&1) entries[i] |= 0x800000;
1711         if (i&2) entries[i] |= 0x8000;
1712         if (i&4) entries[i] |= 0x80;
1713     }
1714
1715     if (8 < count)
1716         entries[i] = 0xffc0c0c0;
1717
1718     for (i=9; i<16 && i<count; i++)
1719     {
1720         entries[i] = 0xff000000;
1721         if (i&1) entries[i] |= 0xff0000;
1722         if (i&2) entries[i] |= 0xff00;
1723         if (i&4) entries[i] |= 0xff;
1724     }
1725
1726     for (i=16; i<40 && i<count; i++)
1727     {
1728         entries[i] = 0;
1729     }
1730
1731     for (i=40; i<256 && i<count; i++)
1732     {
1733         entries[i] = 0xff000000;
1734         entries[i] |= halftone_values[(i-40)%6];
1735         entries[i] |= halftone_values[((i-40)/6)%6] << 8;
1736         entries[i] |= halftone_values[((i-40)/36)%6] << 16;
1737     }
1738 }
1739
1740 static GpStatus get_screen_resolution(REAL *xres, REAL *yres)
1741 {
1742     HDC screendc = CreateCompatibleDC(0);
1743
1744     if (!screendc) return GenericError;
1745
1746     *xres = (REAL)GetDeviceCaps(screendc, LOGPIXELSX);
1747     *yres = (REAL)GetDeviceCaps(screendc, LOGPIXELSY);
1748
1749     DeleteDC(screendc);
1750
1751     return Ok;
1752 }
1753
1754 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
1755     PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
1756 {
1757     HBITMAP hbitmap=NULL;
1758     INT row_size, dib_stride;
1759     BYTE *bits=NULL, *own_bits=NULL;
1760     REAL xres, yres;
1761     GpStatus stat;
1762
1763     TRACE("%d %d %d 0x%x %p %p\n", width, height, stride, format, scan0, bitmap);
1764
1765     if (!bitmap) return InvalidParameter;
1766
1767     if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
1768         *bitmap = NULL;
1769         return InvalidParameter;
1770     }
1771
1772     if(scan0 && !stride)
1773         return InvalidParameter;
1774
1775     stat = get_screen_resolution(&xres, &yres);
1776     if (stat != Ok) return stat;
1777
1778     row_size = (width * PIXELFORMATBPP(format)+7) / 8;
1779     dib_stride = (row_size + 3) & ~3;
1780
1781     if(stride == 0)
1782         stride = dib_stride;
1783
1784     if (format & PixelFormatGDI && !(format & (PixelFormatAlpha|PixelFormatIndexed)) && !scan0)
1785     {
1786         char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
1787         BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
1788
1789         pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1790         pbmi->bmiHeader.biWidth = width;
1791         pbmi->bmiHeader.biHeight = -height;
1792         pbmi->bmiHeader.biPlanes = 1;
1793         /* FIXME: use the rest of the data from format */
1794         pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(format);
1795         pbmi->bmiHeader.biCompression = BI_RGB;
1796         pbmi->bmiHeader.biSizeImage = 0;
1797         pbmi->bmiHeader.biXPelsPerMeter = 0;
1798         pbmi->bmiHeader.biYPelsPerMeter = 0;
1799         pbmi->bmiHeader.biClrUsed = 0;
1800         pbmi->bmiHeader.biClrImportant = 0;
1801
1802         hbitmap = CreateDIBSection(0, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1803
1804         if (!hbitmap) return GenericError;
1805
1806         stride = dib_stride;
1807     }
1808     else
1809     {
1810         /* Not a GDI format; don't try to make an HBITMAP. */
1811         if (scan0)
1812             bits = scan0;
1813         else
1814         {
1815             INT size = abs(stride) * height;
1816
1817             own_bits = bits = heap_alloc_zero(size);
1818             if (!own_bits) return OutOfMemory;
1819
1820             if (stride < 0)
1821                 bits += stride * (1 - height);
1822         }
1823     }
1824
1825     *bitmap = heap_alloc_zero(sizeof(GpBitmap));
1826     if(!*bitmap)
1827     {
1828         DeleteObject(hbitmap);
1829         heap_free(own_bits);
1830         return OutOfMemory;
1831     }
1832
1833     (*bitmap)->image.type = ImageTypeBitmap;
1834     memcpy(&(*bitmap)->image.format, &ImageFormatMemoryBMP, sizeof(GUID));
1835     (*bitmap)->image.flags = ImageFlagsNone;
1836     (*bitmap)->image.frame_count = 1;
1837     (*bitmap)->image.current_frame = 0;
1838     (*bitmap)->image.palette = NULL;
1839     (*bitmap)->image.xres = xres;
1840     (*bitmap)->image.yres = yres;
1841     (*bitmap)->width = width;
1842     (*bitmap)->height = height;
1843     (*bitmap)->format = format;
1844     (*bitmap)->image.decoder = NULL;
1845     (*bitmap)->hbitmap = hbitmap;
1846     (*bitmap)->hdc = NULL;
1847     (*bitmap)->bits = bits;
1848     (*bitmap)->stride = stride;
1849     (*bitmap)->own_bits = own_bits;
1850     (*bitmap)->metadata_reader = NULL;
1851     (*bitmap)->prop_count = 0;
1852     (*bitmap)->prop_item = NULL;
1853
1854     /* set format-related flags */
1855     if (format & (PixelFormatAlpha|PixelFormatPAlpha|PixelFormatIndexed))
1856         (*bitmap)->image.flags |= ImageFlagsHasAlpha;
1857
1858     if (format == PixelFormat1bppIndexed ||
1859         format == PixelFormat4bppIndexed ||
1860         format == PixelFormat8bppIndexed)
1861     {
1862         (*bitmap)->image.palette = heap_alloc_zero(sizeof(UINT) * 2 + sizeof(ARGB) * (1 << PIXELFORMATBPP(format)));
1863
1864         if (!(*bitmap)->image.palette)
1865         {
1866             GdipDisposeImage(&(*bitmap)->image);
1867             *bitmap = NULL;
1868             return OutOfMemory;
1869         }
1870
1871         (*bitmap)->image.palette->Count = 1 << PIXELFORMATBPP(format);
1872
1873         if (format == PixelFormat1bppIndexed)
1874         {
1875             (*bitmap)->image.palette->Flags = PaletteFlagsGrayScale;
1876             (*bitmap)->image.palette->Entries[0] = 0xff000000;
1877             (*bitmap)->image.palette->Entries[1] = 0xffffffff;
1878         }
1879         else
1880         {
1881             if (format == PixelFormat8bppIndexed)
1882                 (*bitmap)->image.palette->Flags = PaletteFlagsHalftone;
1883
1884             generate_halftone_palette((*bitmap)->image.palette->Entries,
1885                 (*bitmap)->image.palette->Count);
1886         }
1887     }
1888
1889     TRACE("<-- %p\n", *bitmap);
1890
1891     return Ok;
1892 }
1893
1894 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
1895     GpBitmap **bitmap)
1896 {
1897     GpStatus stat;
1898
1899     TRACE("%p %p\n", stream, bitmap);
1900
1901     stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
1902
1903     if(stat != Ok)
1904         return stat;
1905
1906     if((*bitmap)->image.type != ImageTypeBitmap){
1907         GdipDisposeImage(&(*bitmap)->image);
1908         *bitmap = NULL;
1909         return GenericError; /* FIXME: what error to return? */
1910     }
1911
1912     return Ok;
1913 }
1914
1915 /* FIXME: no icm */
1916 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
1917     GpBitmap **bitmap)
1918 {
1919     TRACE("%p %p\n", stream, bitmap);
1920
1921     return GdipCreateBitmapFromStream(stream, bitmap);
1922 }
1923
1924 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
1925     GpCachedBitmap **cachedbmp)
1926 {
1927     GpStatus stat;
1928
1929     TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
1930
1931     if(!bitmap || !graphics || !cachedbmp)
1932         return InvalidParameter;
1933
1934     *cachedbmp = heap_alloc_zero(sizeof(GpCachedBitmap));
1935     if(!*cachedbmp)
1936         return OutOfMemory;
1937
1938     stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
1939     if(stat != Ok){
1940         heap_free(*cachedbmp);
1941         return stat;
1942     }
1943
1944     return Ok;
1945 }
1946
1947 GpStatus WINGDIPAPI GdipCreateHICONFromBitmap(GpBitmap *bitmap, HICON *hicon)
1948 {
1949     GpStatus stat;
1950     BitmapData lockeddata;
1951     ULONG andstride, xorstride, bitssize;
1952     LPBYTE andbits, xorbits, androw, xorrow, srcrow;
1953     UINT x, y;
1954
1955     TRACE("(%p, %p)\n", bitmap, hicon);
1956
1957     if (!bitmap || !hicon)
1958         return InvalidParameter;
1959
1960     stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead,
1961         PixelFormat32bppPARGB, &lockeddata);
1962     if (stat == Ok)
1963     {
1964         andstride = ((lockeddata.Width+31)/32)*4;
1965         xorstride = lockeddata.Width*4;
1966         bitssize = (andstride + xorstride) * lockeddata.Height;
1967
1968         andbits = heap_alloc_zero(bitssize);
1969
1970         if (andbits)
1971         {
1972             xorbits = andbits + andstride * lockeddata.Height;
1973
1974             for (y=0; y<lockeddata.Height; y++)
1975             {
1976                 srcrow = ((LPBYTE)lockeddata.Scan0) + lockeddata.Stride * y;
1977
1978                 androw = andbits + andstride * y;
1979                 for (x=0; x<lockeddata.Width; x++)
1980                     if (srcrow[3+4*x] >= 128)
1981                         androw[x/8] |= 1 << (7-x%8);
1982
1983                 xorrow = xorbits + xorstride * y;
1984                 memcpy(xorrow, srcrow, xorstride);
1985             }
1986
1987             *hicon = CreateIcon(NULL, lockeddata.Width, lockeddata.Height, 1, 32,
1988                 andbits, xorbits);
1989
1990             heap_free(andbits);
1991         }
1992         else
1993             stat = OutOfMemory;
1994
1995         GdipBitmapUnlockBits(bitmap, &lockeddata);
1996     }
1997
1998     return stat;
1999 }
2000
2001 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
2002 {
2003     TRACE("%p\n", cachedbmp);
2004
2005     if(!cachedbmp)
2006         return InvalidParameter;
2007
2008     GdipDisposeImage(cachedbmp->image);
2009     heap_free(cachedbmp);
2010
2011     return Ok;
2012 }
2013
2014 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
2015     GpCachedBitmap *cachedbmp, INT x, INT y)
2016 {
2017     TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
2018
2019     if(!graphics || !cachedbmp)
2020         return InvalidParameter;
2021
2022     return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
2023 }
2024
2025 /* Internal utility function: Replace the image data of dst with that of src,
2026  * and free src. */
2027 static void move_bitmap(GpBitmap *dst, GpBitmap *src, BOOL clobber_palette)
2028 {
2029     assert(src->image.type == ImageTypeBitmap);
2030     assert(dst->image.type == ImageTypeBitmap);
2031
2032     heap_free(dst->bitmapbits);
2033     heap_free(dst->own_bits);
2034     DeleteDC(dst->hdc);
2035     DeleteObject(dst->hbitmap);
2036
2037     if (clobber_palette)
2038     {
2039         heap_free(dst->image.palette);
2040         dst->image.palette = src->image.palette;
2041     }
2042     else
2043         heap_free(src->image.palette);
2044
2045     dst->image.xres = src->image.xres;
2046     dst->image.yres = src->image.yres;
2047     dst->width = src->width;
2048     dst->height = src->height;
2049     dst->format = src->format;
2050     dst->hbitmap = src->hbitmap;
2051     dst->hdc = src->hdc;
2052     dst->bits = src->bits;
2053     dst->stride = src->stride;
2054     dst->own_bits = src->own_bits;
2055     if (dst->metadata_reader)
2056         IWICMetadataReader_Release(dst->metadata_reader);
2057     dst->metadata_reader = src->metadata_reader;
2058     heap_free(dst->prop_item);
2059     dst->prop_item = src->prop_item;
2060     dst->prop_count = src->prop_count;
2061     if (dst->image.decoder)
2062         IWICBitmapDecoder_Release(dst->image.decoder);
2063     dst->image.decoder = src->image.decoder;
2064     dst->image.frame_count = src->image.frame_count;
2065     dst->image.current_frame = src->image.current_frame;
2066     dst->image.format = src->image.format;
2067
2068     src->image.type = ~0;
2069     heap_free(src);
2070 }
2071
2072 static GpStatus free_image_data(GpImage *image)
2073 {
2074     if(!image)
2075         return InvalidParameter;
2076
2077     if (image->type == ImageTypeBitmap)
2078     {
2079         heap_free(((GpBitmap*)image)->bitmapbits);
2080         heap_free(((GpBitmap*)image)->own_bits);
2081         DeleteDC(((GpBitmap*)image)->hdc);
2082         DeleteObject(((GpBitmap*)image)->hbitmap);
2083         if (((GpBitmap*)image)->metadata_reader)
2084             IWICMetadataReader_Release(((GpBitmap*)image)->metadata_reader);
2085         heap_free(((GpBitmap*)image)->prop_item);
2086     }
2087     else if (image->type == ImageTypeMetafile)
2088         METAFILE_Free((GpMetafile *)image);
2089     else
2090     {
2091         WARN("invalid image: %p\n", image);
2092         return ObjectBusy;
2093     }
2094     if (image->decoder)
2095         IWICBitmapDecoder_Release(image->decoder);
2096     heap_free(image->palette);
2097
2098     return Ok;
2099 }
2100
2101 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
2102 {
2103     GpStatus status;
2104
2105     TRACE("%p\n", image);
2106
2107     status = free_image_data(image);
2108     if (status != Ok) return status;
2109     image->type = ~0;
2110     heap_free(image);
2111
2112     return Ok;
2113 }
2114
2115 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
2116 {
2117     static int calls;
2118
2119     TRACE("(%p,%p)\n", image, item);
2120
2121     if(!image || !item)
2122         return InvalidParameter;
2123
2124     if (!(calls++))
2125         FIXME("not implemented\n");
2126
2127     return NotImplemented;
2128 }
2129
2130 GpStatus WINGDIPAPI GdipGetImageItemData(GpImage *image, ImageItemData *item)
2131 {
2132     static int calls;
2133
2134     TRACE("(%p,%p)\n", image, item);
2135
2136     if (!(calls++))
2137         FIXME("not implemented\n");
2138
2139     return NotImplemented;
2140 }
2141
2142 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
2143     GpUnit *srcUnit)
2144 {
2145     TRACE("%p %p %p\n", image, srcRect, srcUnit);
2146
2147     if(!image || !srcRect || !srcUnit)
2148         return InvalidParameter;
2149     if(image->type == ImageTypeMetafile){
2150         *srcRect = ((GpMetafile*)image)->bounds;
2151         *srcUnit = ((GpMetafile*)image)->unit;
2152     }
2153     else if(image->type == ImageTypeBitmap){
2154         srcRect->X = srcRect->Y = 0.0;
2155         srcRect->Width = (REAL) ((GpBitmap*)image)->width;
2156         srcRect->Height = (REAL) ((GpBitmap*)image)->height;
2157         *srcUnit = UnitPixel;
2158     }
2159     else{
2160         WARN("GpImage with no image data\n");
2161         return InvalidParameter;
2162     }
2163
2164     TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
2165           srcRect->Width, srcRect->Height, *srcUnit);
2166
2167     return Ok;
2168 }
2169
2170 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
2171     REAL *height)
2172 {
2173     TRACE("%p %p %p\n", image, width, height);
2174
2175     if(!image || !height || !width)
2176         return InvalidParameter;
2177
2178     if(image->type == ImageTypeMetafile){
2179         *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2180         *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2181     }
2182     else if(image->type == ImageTypeBitmap){
2183         *height = ((GpBitmap*)image)->height;
2184         *width = ((GpBitmap*)image)->width;
2185     }
2186     else{
2187         WARN("GpImage with no image data\n");
2188         return InvalidParameter;
2189     }
2190
2191     TRACE("returning (%f, %f)\n", *height, *width);
2192     return Ok;
2193 }
2194
2195 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
2196     GpGraphics **graphics)
2197 {
2198     HDC hdc;
2199     GpStatus stat;
2200
2201     TRACE("%p %p\n", image, graphics);
2202
2203     if(!image || !graphics)
2204         return InvalidParameter;
2205
2206     if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
2207     {
2208         hdc = ((GpBitmap*)image)->hdc;
2209
2210         if(!hdc){
2211             hdc = CreateCompatibleDC(0);
2212             SelectObject(hdc, ((GpBitmap*)image)->hbitmap);
2213             ((GpBitmap*)image)->hdc = hdc;
2214         }
2215
2216         stat = GdipCreateFromHDC(hdc, graphics);
2217
2218         if (stat == Ok)
2219         {
2220             (*graphics)->image = image;
2221             (*graphics)->xres = image->xres;
2222             (*graphics)->yres = image->yres;
2223         }
2224     }
2225     else if (image->type == ImageTypeMetafile)
2226         stat = METAFILE_GetGraphicsContext((GpMetafile*)image, graphics);
2227     else
2228         stat = graphics_from_image(image, graphics);
2229
2230     return stat;
2231 }
2232
2233 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
2234 {
2235     TRACE("%p %p\n", image, height);
2236
2237     if(!image || !height)
2238         return InvalidParameter;
2239
2240     if(image->type == ImageTypeMetafile)
2241         *height = units_to_pixels(((GpMetafile*)image)->bounds.Height, ((GpMetafile*)image)->unit, image->yres);
2242     else if(image->type == ImageTypeBitmap)
2243         *height = ((GpBitmap*)image)->height;
2244     else
2245     {
2246         WARN("GpImage with no image data\n");
2247         return InvalidParameter;
2248     }
2249
2250     TRACE("returning %d\n", *height);
2251
2252     return Ok;
2253 }
2254
2255 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
2256 {
2257     if(!image || !res)
2258         return InvalidParameter;
2259
2260     *res = image->xres;
2261
2262     TRACE("(%p) <-- %0.2f\n", image, *res);
2263
2264     return Ok;
2265 }
2266
2267 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
2268 {
2269     TRACE("%p %p\n", image, size);
2270
2271     if(!image || !size)
2272         return InvalidParameter;
2273
2274     if (!image->palette || image->palette->Count == 0)
2275         *size = sizeof(ColorPalette);
2276     else
2277         *size = sizeof(UINT)*2 + sizeof(ARGB)*image->palette->Count;
2278
2279     TRACE("<-- %u\n", *size);
2280
2281     return Ok;
2282 }
2283
2284 /* FIXME: test this function for non-bitmap types */
2285 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
2286 {
2287     TRACE("%p %p\n", image, format);
2288
2289     if(!image || !format)
2290         return InvalidParameter;
2291
2292     if(image->type != ImageTypeBitmap)
2293         *format = PixelFormat24bppRGB;
2294     else
2295         *format = ((GpBitmap*) image)->format;
2296
2297     return Ok;
2298 }
2299
2300 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
2301 {
2302     TRACE("(%p, %p)\n", image, format);
2303
2304     if(!image || !format)
2305         return InvalidParameter;
2306
2307     memcpy(format, &image->format, sizeof(GUID));
2308
2309     return Ok;
2310 }
2311
2312 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
2313 {
2314     TRACE("%p %p\n", image, type);
2315
2316     if(!image || !type)
2317         return InvalidParameter;
2318
2319     *type = image->type;
2320
2321     return Ok;
2322 }
2323
2324 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
2325 {
2326     if(!image || !res)
2327         return InvalidParameter;
2328
2329     *res = image->yres;
2330
2331     TRACE("(%p) <-- %0.2f\n", image, *res);
2332
2333     return Ok;
2334 }
2335
2336 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
2337 {
2338     TRACE("%p %p\n", image, width);
2339
2340     if(!image || !width)
2341         return InvalidParameter;
2342
2343     if(image->type == ImageTypeMetafile)
2344         *width = units_to_pixels(((GpMetafile*)image)->bounds.Width, ((GpMetafile*)image)->unit, image->xres);
2345     else if(image->type == ImageTypeBitmap)
2346         *width = ((GpBitmap*)image)->width;
2347     else
2348     {
2349         WARN("GpImage with no image data\n");
2350         return InvalidParameter;
2351     }
2352
2353     TRACE("returning %d\n", *width);
2354
2355     return Ok;
2356 }
2357
2358 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT *num)
2359 {
2360     TRACE("(%p, %p)\n", image, num);
2361
2362     if (!image || !num) return InvalidParameter;
2363
2364     *num = 0;
2365
2366     if (image->type == ImageTypeBitmap)
2367     {
2368         if (((GpBitmap *)image)->prop_item)
2369         {
2370             *num = ((GpBitmap *)image)->prop_count;
2371             return Ok;
2372         }
2373
2374         if (((GpBitmap *)image)->metadata_reader)
2375             IWICMetadataReader_GetCount(((GpBitmap *)image)->metadata_reader, num);
2376     }
2377
2378     return Ok;
2379 }
2380
2381 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID *list)
2382 {
2383     HRESULT hr;
2384     IWICMetadataReader *reader;
2385     IWICEnumMetadataItem *enumerator;
2386     UINT prop_count, i, items_returned;
2387
2388     TRACE("(%p, %u, %p)\n", image, num, list);
2389
2390     if (!image || !list) return InvalidParameter;
2391
2392     if (image->type != ImageTypeBitmap)
2393     {
2394         FIXME("Not implemented for type %d\n", image->type);
2395         return NotImplemented;
2396     }
2397
2398     if (((GpBitmap *)image)->prop_item)
2399     {
2400         if (num != ((GpBitmap *)image)->prop_count) return InvalidParameter;
2401
2402         for (i = 0; i < num; i++)
2403         {
2404             list[i] = ((GpBitmap *)image)->prop_item[i].id;
2405         }
2406
2407         return Ok;
2408     }
2409
2410     reader = ((GpBitmap *)image)->metadata_reader;
2411     if (!reader)
2412     {
2413         if (num != 0) return InvalidParameter;
2414         return Ok;
2415     }
2416
2417     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2418     if (FAILED(hr)) return hresult_to_status(hr);
2419
2420     if (num != prop_count) return InvalidParameter;
2421
2422     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2423     if (FAILED(hr)) return hresult_to_status(hr);
2424
2425     IWICEnumMetadataItem_Reset(enumerator);
2426
2427     for (i = 0; i < num; i++)
2428     {
2429         PROPVARIANT id;
2430
2431         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, NULL, &items_returned);
2432         if (hr != S_OK) break;
2433
2434         if (id.vt != VT_UI2)
2435         {
2436             FIXME("not supported propvariant type for id: %u\n", id.vt);
2437             list[i] = 0;
2438             continue;
2439         }
2440         list[i] = id.u.uiVal;
2441     }
2442
2443     IWICEnumMetadataItem_Release(enumerator);
2444
2445     return hr == S_OK ? Ok : hresult_to_status(hr);
2446 }
2447
2448 static UINT propvariant_size(PROPVARIANT *value)
2449 {
2450     switch (value->vt & ~VT_VECTOR)
2451     {
2452     case VT_EMPTY:
2453         return 0;
2454     case VT_I1:
2455     case VT_UI1:
2456         if (!(value->vt & VT_VECTOR)) return 1;
2457         return value->u.caub.cElems;
2458     case VT_I2:
2459     case VT_UI2:
2460         if (!(value->vt & VT_VECTOR)) return 2;
2461         return value->u.caui.cElems * 2;
2462     case VT_I4:
2463     case VT_UI4:
2464     case VT_R4:
2465         if (!(value->vt & VT_VECTOR)) return 4;
2466         return value->u.caul.cElems * 4;
2467     case VT_I8:
2468     case VT_UI8:
2469     case VT_R8:
2470         if (!(value->vt & VT_VECTOR)) return 8;
2471         return value->u.cauh.cElems * 8;
2472     case VT_LPSTR:
2473         return value->u.pszVal ? strlen(value->u.pszVal) + 1 : 0;
2474     case VT_BLOB:
2475         return value->u.blob.cbSize;
2476     default:
2477         FIXME("not supported variant type %d\n", value->vt);
2478         return 0;
2479     }
2480 }
2481
2482 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID propid, UINT *size)
2483 {
2484     HRESULT hr;
2485     IWICMetadataReader *reader;
2486     PROPVARIANT id, value;
2487
2488     TRACE("(%p,%#x,%p)\n", image, propid, size);
2489
2490     if (!size || !image) return InvalidParameter;
2491
2492     if (image->type != ImageTypeBitmap)
2493     {
2494         FIXME("Not implemented for type %d\n", image->type);
2495         return NotImplemented;
2496     }
2497
2498     if (((GpBitmap *)image)->prop_item)
2499     {
2500         UINT i;
2501
2502         for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2503         {
2504             if (propid == ((GpBitmap *)image)->prop_item[i].id)
2505             {
2506                 *size = sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2507                 return Ok;
2508             }
2509         }
2510
2511         return PropertyNotFound;
2512     }
2513
2514     reader = ((GpBitmap *)image)->metadata_reader;
2515     if (!reader) return PropertyNotFound;
2516
2517     id.vt = VT_UI2;
2518     id.u.uiVal = propid;
2519     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2520     if (FAILED(hr)) return PropertyNotFound;
2521
2522     *size = propvariant_size(&value);
2523     if (*size) *size += sizeof(PropertyItem);
2524     PropVariantClear(&value);
2525
2526     return Ok;
2527 }
2528
2529 #ifndef PropertyTagTypeSByte
2530 #define PropertyTagTypeSByte  6
2531 #define PropertyTagTypeSShort 8
2532 #define PropertyTagTypeFloat  11
2533 #define PropertyTagTypeDouble 12
2534 #endif
2535
2536 static UINT vt_to_itemtype(UINT vt)
2537 {
2538     static const struct
2539     {
2540         UINT vt, type;
2541     } vt2type[] =
2542     {
2543         { VT_I1, PropertyTagTypeSByte },
2544         { VT_UI1, PropertyTagTypeByte },
2545         { VT_I2, PropertyTagTypeSShort },
2546         { VT_UI2, PropertyTagTypeShort },
2547         { VT_I4, PropertyTagTypeSLONG },
2548         { VT_UI4, PropertyTagTypeLong },
2549         { VT_I8, PropertyTagTypeSRational },
2550         { VT_UI8, PropertyTagTypeRational },
2551         { VT_R4, PropertyTagTypeFloat },
2552         { VT_R8, PropertyTagTypeDouble },
2553         { VT_LPSTR, PropertyTagTypeASCII },
2554         { VT_BLOB, PropertyTagTypeUndefined }
2555     };
2556     UINT i;
2557     for (i = 0; i < sizeof(vt2type)/sizeof(vt2type[0]); i++)
2558     {
2559         if (vt2type[i].vt == vt) return vt2type[i].type;
2560     }
2561     FIXME("not supported variant type %u\n", vt);
2562     return 0;
2563 }
2564
2565 static GpStatus propvariant_to_item(PROPVARIANT *value, PropertyItem *item,
2566                                     UINT size, PROPID id)
2567 {
2568     UINT item_size, item_type;
2569
2570     item_size = propvariant_size(value);
2571     if (size != item_size + sizeof(PropertyItem)) return InvalidParameter;
2572
2573     item_type = vt_to_itemtype(value->vt & ~VT_VECTOR);
2574     if (!item_type) return InvalidParameter;
2575
2576     item->value = item + 1;
2577
2578     switch (value->vt & ~VT_VECTOR)
2579     {
2580     case VT_I1:
2581     case VT_UI1:
2582         if (!(value->vt & VT_VECTOR))
2583             *(BYTE *)item->value = value->u.bVal;
2584         else
2585             memcpy(item->value, value->u.caub.pElems, item_size);
2586         break;
2587     case VT_I2:
2588     case VT_UI2:
2589         if (!(value->vt & VT_VECTOR))
2590             *(USHORT *)item->value = value->u.uiVal;
2591         else
2592             memcpy(item->value, value->u.caui.pElems, item_size);
2593         break;
2594     case VT_I4:
2595     case VT_UI4:
2596     case VT_R4:
2597         if (!(value->vt & VT_VECTOR))
2598             *(ULONG *)item->value = value->u.ulVal;
2599         else
2600             memcpy(item->value, value->u.caul.pElems, item_size);
2601         break;
2602     case VT_I8:
2603     case VT_UI8:
2604     case VT_R8:
2605         if (!(value->vt & VT_VECTOR))
2606             *(ULONGLONG *)item->value = value->u.uhVal.QuadPart;
2607         else
2608             memcpy(item->value, value->u.cauh.pElems, item_size);
2609         break;
2610     case VT_LPSTR:
2611         memcpy(item->value, value->u.pszVal, item_size);
2612         break;
2613     case VT_BLOB:
2614         memcpy(item->value, value->u.blob.pBlobData, item_size);
2615         break;
2616     default:
2617         FIXME("not supported variant type %d\n", value->vt);
2618         return InvalidParameter;
2619     }
2620
2621     item->length = item_size;
2622     item->type = item_type;
2623     item->id = id;
2624
2625     return Ok;
2626 }
2627
2628 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID propid, UINT size,
2629                                         PropertyItem *buffer)
2630 {
2631     GpStatus stat;
2632     HRESULT hr;
2633     IWICMetadataReader *reader;
2634     PROPVARIANT id, value;
2635
2636     TRACE("(%p,%#x,%u,%p)\n", image, propid, size, buffer);
2637
2638     if (!image || !buffer) return InvalidParameter;
2639
2640     if (image->type != ImageTypeBitmap)
2641     {
2642         FIXME("Not implemented for type %d\n", image->type);
2643         return NotImplemented;
2644     }
2645
2646     if (((GpBitmap *)image)->prop_item)
2647     {
2648         UINT i;
2649
2650         for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2651         {
2652             if (propid == ((GpBitmap *)image)->prop_item[i].id)
2653             {
2654                 if (size != sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length)
2655                     return InvalidParameter;
2656
2657                 *buffer = ((GpBitmap *)image)->prop_item[i];
2658                 buffer->value = buffer + 1;
2659                 memcpy(buffer->value, ((GpBitmap *)image)->prop_item[i].value, buffer->length);
2660                 return Ok;
2661             }
2662         }
2663
2664         return PropertyNotFound;
2665     }
2666
2667     reader = ((GpBitmap *)image)->metadata_reader;
2668     if (!reader) return PropertyNotFound;
2669
2670     id.vt = VT_UI2;
2671     id.u.uiVal = propid;
2672     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
2673     if (FAILED(hr)) return PropertyNotFound;
2674
2675     stat = propvariant_to_item(&value, buffer, size, propid);
2676     PropVariantClear(&value);
2677
2678     return stat;
2679 }
2680
2681 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT *size, UINT *count)
2682 {
2683     HRESULT hr;
2684     IWICMetadataReader *reader;
2685     IWICEnumMetadataItem *enumerator;
2686     UINT prop_count, prop_size, i;
2687     PROPVARIANT id, value;
2688
2689     TRACE("(%p,%p,%p)\n", image, size, count);
2690
2691     if (!image || !size || !count) return InvalidParameter;
2692
2693     if (image->type != ImageTypeBitmap)
2694     {
2695         FIXME("Not implemented for type %d\n", image->type);
2696         return NotImplemented;
2697     }
2698
2699     if (((GpBitmap *)image)->prop_item)
2700     {
2701         *count = ((GpBitmap *)image)->prop_count;
2702         *size = 0;
2703
2704         for (i = 0; i < ((GpBitmap *)image)->prop_count; i++)
2705         {
2706             *size += sizeof(PropertyItem) + ((GpBitmap *)image)->prop_item[i].length;
2707         }
2708
2709         return Ok;
2710     }
2711
2712     reader = ((GpBitmap *)image)->metadata_reader;
2713     if (!reader) return PropertyNotFound;
2714
2715     hr = IWICMetadataReader_GetCount(reader, &prop_count);
2716     if (FAILED(hr)) return hresult_to_status(hr);
2717
2718     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2719     if (FAILED(hr)) return hresult_to_status(hr);
2720
2721     IWICEnumMetadataItem_Reset(enumerator);
2722
2723     prop_size = 0;
2724
2725     PropVariantInit(&id);
2726     PropVariantInit(&value);
2727
2728     for (i = 0; i < prop_count; i++)
2729     {
2730         UINT items_returned, item_size;
2731
2732         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2733         if (hr != S_OK) break;
2734
2735         item_size = propvariant_size(&value);
2736         if (item_size) prop_size += sizeof(PropertyItem) + item_size;
2737
2738         PropVariantClear(&id);
2739         PropVariantClear(&value);
2740     }
2741
2742     IWICEnumMetadataItem_Release(enumerator);
2743
2744     if (hr != S_OK) return PropertyNotFound;
2745
2746     *count = prop_count;
2747     *size = prop_size;
2748     return Ok;
2749 }
2750
2751 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
2752                                             UINT count, PropertyItem *buf)
2753 {
2754     GpStatus status;
2755     HRESULT hr;
2756     IWICMetadataReader *reader;
2757     IWICEnumMetadataItem *enumerator;
2758     UINT prop_count, prop_size, i;
2759     PROPVARIANT id, value;
2760     char *item_value;
2761
2762     TRACE("(%p,%u,%u,%p)\n", image, size, count, buf);
2763
2764     if (!image || !buf) return InvalidParameter;
2765
2766     if (image->type != ImageTypeBitmap)
2767     {
2768         FIXME("Not implemented for type %d\n", image->type);
2769         return NotImplemented;
2770     }
2771
2772     status = GdipGetPropertySize(image, &prop_size, &prop_count);
2773     if (status != Ok) return status;
2774
2775     if (prop_count != count || prop_size != size) return InvalidParameter;
2776
2777     if (((GpBitmap *)image)->prop_item)
2778     {
2779         memcpy(buf, ((GpBitmap *)image)->prop_item, prop_size);
2780
2781         item_value = (char *)(buf + prop_count);
2782
2783         for (i = 0; i < prop_count; i++)
2784         {
2785             buf[i].value = item_value;
2786             item_value += buf[i].length;
2787         }
2788
2789         return Ok;
2790     }
2791
2792     reader = ((GpBitmap *)image)->metadata_reader;
2793     if (!reader) return PropertyNotFound;
2794
2795     hr = IWICMetadataReader_GetEnumerator(reader, &enumerator);
2796     if (FAILED(hr)) return hresult_to_status(hr);
2797
2798     IWICEnumMetadataItem_Reset(enumerator);
2799
2800     item_value = (char *)(buf + prop_count);
2801
2802     PropVariantInit(&id);
2803     PropVariantInit(&value);
2804
2805     for (i = 0; i < prop_count; i++)
2806     {
2807         PropertyItem *item;
2808         UINT items_returned, item_size;
2809
2810         hr = IWICEnumMetadataItem_Next(enumerator, 1, NULL, &id, &value, &items_returned);
2811         if (hr != S_OK) break;
2812
2813         if (id.vt != VT_UI2)
2814         {
2815             FIXME("not supported propvariant type for id: %u\n", id.vt);
2816             continue;
2817         }
2818
2819         item_size = propvariant_size(&value);
2820         if (item_size)
2821         {
2822             item = heap_alloc(item_size + sizeof(*item));
2823
2824             propvariant_to_item(&value, item, item_size + sizeof(*item), id.u.uiVal);
2825             buf[i].id = item->id;
2826             buf[i].type = item->type;
2827             buf[i].length = item_size;
2828             buf[i].value = item_value;
2829             memcpy(item_value, item->value, item_size);
2830             item_value += item_size;
2831
2832             heap_free(item);
2833         }
2834
2835         PropVariantClear(&id);
2836         PropVariantClear(&value);
2837     }
2838
2839     IWICEnumMetadataItem_Release(enumerator);
2840
2841     if (hr != S_OK) return PropertyNotFound;
2842
2843     return Ok;
2844 }
2845
2846 struct image_format_dimension
2847 {
2848     const GUID *format;
2849     const GUID *dimension;
2850 };
2851
2852 static const struct image_format_dimension image_format_dimensions[] =
2853 {
2854     {&ImageFormatGIF, &FrameDimensionTime},
2855     {&ImageFormatIcon, &FrameDimensionResolution},
2856     {NULL}
2857 };
2858
2859 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
2860     GDIPCONST GUID* dimensionID, UINT* count)
2861 {
2862     TRACE("(%p,%s,%p)\n", image, debugstr_guid(dimensionID), count);
2863
2864     if(!image || !count)
2865         return InvalidParameter;
2866
2867     if (!dimensionID ||
2868         IsEqualGUID(dimensionID, &image->format) ||
2869         IsEqualGUID(dimensionID, &FrameDimensionPage) ||
2870         IsEqualGUID(dimensionID, &FrameDimensionTime))
2871     {
2872         *count = image->frame_count;
2873         return Ok;
2874     }
2875
2876     return InvalidParameter;
2877 }
2878
2879 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
2880     UINT* count)
2881 {
2882     TRACE("(%p, %p)\n", image, count);
2883
2884     /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2885
2886     if(!image || !count)
2887         return InvalidParameter;
2888
2889     *count = 1;
2890
2891     return Ok;
2892 }
2893
2894 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
2895     GUID* dimensionIDs, UINT count)
2896 {
2897     int i;
2898     const GUID *result=NULL;
2899
2900     TRACE("(%p,%p,%u)\n", image, dimensionIDs, count);
2901
2902     if(!image || !dimensionIDs || count != 1)
2903         return InvalidParameter;
2904
2905     for (i=0; image_format_dimensions[i].format; i++)
2906     {
2907         if (IsEqualGUID(&image->format, image_format_dimensions[i].format))
2908         {
2909             result = image_format_dimensions[i].dimension;
2910             break;
2911         }
2912     }
2913
2914     if (!result)
2915         result = &FrameDimensionPage;
2916
2917     memcpy(dimensionIDs, result, sizeof(GUID));
2918
2919     return Ok;
2920 }
2921
2922 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
2923                                           GpImage **image)
2924 {
2925     GpStatus stat;
2926     IStream *stream;
2927
2928     TRACE("(%s) %p\n", debugstr_w(filename), image);
2929
2930     if (!filename || !image)
2931         return InvalidParameter;
2932
2933     *image = NULL;
2934
2935     stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
2936
2937     if (stat != Ok)
2938         return stat;
2939
2940     stat = GdipLoadImageFromStream(stream, image);
2941
2942     IStream_Release(stream);
2943
2944     return stat;
2945 }
2946
2947 /* FIXME: no icm handling */
2948 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
2949 {
2950     TRACE("(%s) %p\n", debugstr_w(filename), image);
2951
2952     return GdipLoadImageFromFile(filename, image);
2953 }
2954
2955 static void add_property(GpBitmap *bitmap, PropertyItem *item)
2956 {
2957     UINT prop_size, prop_count;
2958     PropertyItem *prop_item;
2959
2960     if (bitmap->prop_item == NULL)
2961     {
2962         prop_size = prop_count = 0;
2963         prop_item = heap_alloc_zero(item->length + sizeof(PropertyItem));
2964         if (!prop_item) return;
2965     }
2966     else
2967     {
2968         UINT i;
2969         char *item_value;
2970
2971         GdipGetPropertySize(&bitmap->image, &prop_size, &prop_count);
2972
2973         prop_item = heap_alloc_zero(prop_size + item->length + sizeof(PropertyItem));
2974         if (!prop_item) return;
2975         memcpy(prop_item, bitmap->prop_item, sizeof(PropertyItem) * bitmap->prop_count);
2976         prop_size -= sizeof(PropertyItem) * bitmap->prop_count;
2977         memcpy(prop_item + prop_count + 1, bitmap->prop_item + prop_count, prop_size);
2978
2979         item_value = (char *)(prop_item + prop_count + 1);
2980
2981         for (i = 0; i < prop_count; i++)
2982         {
2983             prop_item[i].value = item_value;
2984             item_value += prop_item[i].length;
2985         }
2986     }
2987
2988     prop_item[prop_count].id = item->id;
2989     prop_item[prop_count].type = item->type;
2990     prop_item[prop_count].length = item->length;
2991     prop_item[prop_count].value = (char *)(prop_item + prop_count + 1) + prop_size;
2992     memcpy(prop_item[prop_count].value, item->value, item->length);
2993
2994     heap_free(bitmap->prop_item);
2995     bitmap->prop_item = prop_item;
2996     bitmap->prop_count++;
2997 }
2998
2999 static BOOL get_bool_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3000 {
3001     HRESULT hr;
3002     GUID format;
3003     PROPVARIANT id, value;
3004     BOOL ret = FALSE;
3005
3006     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3007     if (FAILED(hr) || !IsEqualGUID(&format, guid)) return FALSE;
3008
3009     PropVariantInit(&id);
3010     PropVariantInit(&value);
3011
3012     id.vt = VT_LPWSTR;
3013     id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3014     if (!id.u.pwszVal) return FALSE;
3015     lstrcpyW(id.u.pwszVal, prop_name);
3016     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3017     if (hr == S_OK && value.vt == VT_BOOL)
3018         ret = value.u.boolVal;
3019
3020     PropVariantClear(&id);
3021     PropVariantClear(&value);
3022
3023     return ret;
3024 }
3025
3026 static PropertyItem *get_property(IWICMetadataReader *reader, const GUID *guid, const WCHAR *prop_name)
3027 {
3028     HRESULT hr;
3029     GUID format;
3030     PROPVARIANT id, value;
3031     PropertyItem *item = NULL;
3032
3033     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3034     if (FAILED(hr) || !IsEqualGUID(&format, guid)) return NULL;
3035
3036     PropVariantInit(&id);
3037     PropVariantInit(&value);
3038
3039     id.vt = VT_LPWSTR;
3040     id.u.pwszVal = CoTaskMemAlloc((lstrlenW(prop_name) + 1) * sizeof(WCHAR));
3041     if (!id.u.pwszVal) return NULL;
3042     lstrcpyW(id.u.pwszVal, prop_name);
3043     hr = IWICMetadataReader_GetValue(reader, NULL, &id, &value);
3044     if (hr == S_OK)
3045     {
3046         UINT item_size = propvariant_size(&value);
3047         if (item_size)
3048         {
3049             item_size += sizeof(*item);
3050             item = heap_alloc_zero(item_size);
3051             if (propvariant_to_item(&value, item, item_size, 0) != Ok)
3052             {
3053                 heap_free(item);
3054                 item = NULL;
3055             }
3056         }
3057     }
3058
3059     PropVariantClear(&id);
3060     PropVariantClear(&value);
3061
3062     return item;
3063 }
3064
3065 static PropertyItem *get_gif_comment(IWICMetadataReader *reader)
3066 {
3067     static const WCHAR textentryW[] = { 'T','e','x','t','E','n','t','r','y',0 };
3068     PropertyItem *comment;
3069
3070     comment = get_property(reader, &GUID_MetadataFormatGifComment, textentryW);
3071     if (comment)
3072         comment->id = PropertyTagExifUserComment;
3073
3074     return comment;
3075 }
3076
3077 static PropertyItem *get_gif_loopcount(IWICMetadataReader *reader)
3078 {
3079     static const WCHAR applicationW[] = { 'A','p','p','l','i','c','a','t','i','o','n',0 };
3080     static const WCHAR dataW[] = { 'D','a','t','a',0 };
3081     PropertyItem *appext = NULL, *appdata = NULL, *loop = NULL;
3082
3083     appext = get_property(reader, &GUID_MetadataFormatAPE, applicationW);
3084     if (appext)
3085     {
3086         if (appext->type == PropertyTagTypeByte && appext->length == 11 &&
3087             (!memcmp(appext->value, "NETSCAPE2.0", 11) || !memcmp(appext->value, "ANIMEXTS1.0", 11)))
3088         {
3089             appdata = get_property(reader, &GUID_MetadataFormatAPE, dataW);
3090             if (appdata)
3091             {
3092                 if (appdata->type == PropertyTagTypeByte && appdata->length == 4)
3093                 {
3094                     BYTE *data = appdata->value;
3095                     if (data[0] == 3 && data[1] == 1)
3096                     {
3097                         loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
3098                         if (loop)
3099                         {
3100                             loop->type = PropertyTagTypeShort;
3101                             loop->id = PropertyTagLoopCount;
3102                             loop->length = sizeof(SHORT);
3103                             loop->value = loop + 1;
3104                             *(SHORT *)loop->value = data[2] | (data[3] << 8);
3105                         }
3106                     }
3107                 }
3108             }
3109         }
3110     }
3111
3112     heap_free(appext);
3113     heap_free(appdata);
3114
3115     return loop;
3116 }
3117
3118 static PropertyItem *get_gif_background(IWICMetadataReader *reader)
3119 {
3120     static const WCHAR backgroundW[] = { 'B','a','c','k','g','r','o','u','n','d','C','o','l','o','r','I','n','d','e','x',0 };
3121     PropertyItem *background;
3122
3123     background = get_property(reader, &GUID_MetadataFormatLSD, backgroundW);
3124     if (background)
3125         background->id = PropertyTagIndexBackground;
3126
3127     return background;
3128 }
3129
3130 static PropertyItem *get_gif_palette(IWICBitmapDecoder *decoder, IWICMetadataReader *reader)
3131 {
3132     static const WCHAR global_flagW[] = { 'G','l','o','b','a','l','C','o','l','o','r','T','a','b','l','e','F','l','a','g',0 };
3133     HRESULT hr;
3134     IWICImagingFactory *factory;
3135     IWICPalette *palette;
3136     UINT count = 0;
3137     WICColor colors[256];
3138
3139     if (!get_bool_property(reader, &GUID_MetadataFormatLSD, global_flagW))
3140         return NULL;
3141
3142     hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
3143     if (hr != S_OK) return NULL;
3144
3145     hr = IWICImagingFactory_CreatePalette(factory, &palette);
3146     if (hr == S_OK)
3147     {
3148         hr = IWICBitmapDecoder_CopyPalette(decoder, palette);
3149         if (hr == S_OK)
3150             IWICPalette_GetColors(palette, 256, colors, &count);
3151
3152         IWICPalette_Release(palette);
3153     }
3154
3155     IWICImagingFactory_Release(factory);
3156
3157     if (count)
3158     {
3159         PropertyItem *pal;
3160         UINT i;
3161         BYTE *rgb;
3162
3163         pal = heap_alloc_zero(sizeof(*pal) + count * 3);
3164         if (!pal) return NULL;
3165         pal->type = PropertyTagTypeByte;
3166         pal->id = PropertyTagGlobalPalette;
3167         pal->value = pal + 1;
3168         pal->length = count * 3;
3169
3170         rgb = pal->value;
3171
3172         for (i = 0; i < count; i++)
3173         {
3174             rgb[i*3] = (colors[i] >> 16) & 0xff;
3175             rgb[i*3 + 1] = (colors[i] >> 8) & 0xff;
3176             rgb[i*3 + 2] = colors[i] & 0xff;
3177         }
3178
3179         return pal;
3180     }
3181
3182     return NULL;
3183 }
3184
3185 static PropertyItem *get_gif_transparent_idx(IWICMetadataReader *reader)
3186 {
3187     static const WCHAR transparency_flagW[] = { 'T','r','a','n','s','p','a','r','e','n','c','y','F','l','a','g',0 };
3188     static const WCHAR colorW[] = { 'T','r','a','n','s','p','a','r','e','n','t','C','o','l','o','r','I','n','d','e','x',0 };
3189     PropertyItem *index = NULL;
3190
3191     if (get_bool_property(reader, &GUID_MetadataFormatGCE, transparency_flagW))
3192     {
3193         index = get_property(reader, &GUID_MetadataFormatGCE, colorW);
3194         if (index)
3195             index->id = PropertyTagIndexTransparent;
3196     }
3197     return index;
3198 }
3199
3200 static LONG get_gif_frame_property(IWICBitmapFrameDecode *frame, const GUID *format, const WCHAR *property)
3201 {
3202     HRESULT hr;
3203     IWICMetadataBlockReader *block_reader;
3204     IWICMetadataReader *reader;
3205     UINT block_count, i;
3206     PropertyItem *prop;
3207     LONG value = 0;
3208
3209     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3210     if (hr == S_OK)
3211     {
3212         hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3213         if (hr == S_OK)
3214         {
3215             for (i = 0; i < block_count; i++)
3216             {
3217                 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3218                 if (hr == S_OK)
3219                 {
3220                     prop = get_property(reader, format, property);
3221                     if (prop)
3222                     {
3223                         if (prop->type == PropertyTagTypeByte && prop->length == 1)
3224                             value = *(BYTE *)prop->value;
3225                         else if (prop->type == PropertyTagTypeShort && prop->length == 2)
3226                             value = *(SHORT *)prop->value;
3227
3228                         heap_free(prop);
3229                     }
3230                     IWICMetadataReader_Release(reader);
3231                 }
3232             }
3233         }
3234         IWICMetadataBlockReader_Release(block_reader);
3235     }
3236
3237     return value;
3238 }
3239
3240 static void gif_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
3241 {
3242     static const WCHAR delayW[] = { 'D','e','l','a','y',0 };
3243     HRESULT hr;
3244     IWICBitmapFrameDecode *frame;
3245     IWICMetadataBlockReader *block_reader;
3246     IWICMetadataReader *reader;
3247     UINT frame_count, block_count, i;
3248     PropertyItem *delay = NULL, *comment = NULL, *background = NULL;
3249     PropertyItem *transparent_idx = NULL, *loop = NULL, *palette = NULL;
3250
3251     IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3252     if (frame_count > 1)
3253     {
3254         delay = heap_alloc_zero(sizeof(*delay) + frame_count * sizeof(LONG));
3255         if (delay)
3256         {
3257             LONG *value;
3258
3259             delay->type = PropertyTagTypeLong;
3260             delay->id = PropertyTagFrameDelay;
3261             delay->length = frame_count * sizeof(LONG);
3262             delay->value = delay + 1;
3263
3264             value = delay->value;
3265
3266             for (i = 0; i < frame_count; i++)
3267             {
3268                 hr = IWICBitmapDecoder_GetFrame(decoder, i, &frame);
3269                 if (hr == S_OK)
3270                 {
3271                     value[i] = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, delayW);
3272                     IWICBitmapFrameDecode_Release(frame);
3273                 }
3274                 else value[i] = 0;
3275             }
3276         }
3277     }
3278
3279     hr = IWICBitmapDecoder_QueryInterface(decoder, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3280     if (hr == S_OK)
3281     {
3282         hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3283         if (hr == S_OK)
3284         {
3285             for (i = 0; i < block_count; i++)
3286             {
3287                 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3288                 if (hr == S_OK)
3289                 {
3290                     if (!comment)
3291                         comment = get_gif_comment(reader);
3292
3293                     if (frame_count > 1 && !loop)
3294                         loop = get_gif_loopcount(reader);
3295
3296                     if (!background)
3297                         background = get_gif_background(reader);
3298
3299                     if (!palette)
3300                         palette = get_gif_palette(decoder, reader);
3301
3302                     IWICMetadataReader_Release(reader);
3303                 }
3304             }
3305         }
3306         IWICMetadataBlockReader_Release(block_reader);
3307     }
3308
3309     if (frame_count > 1 && !loop)
3310     {
3311         loop = heap_alloc_zero(sizeof(*loop) + sizeof(SHORT));
3312         if (loop)
3313         {
3314             loop->type = PropertyTagTypeShort;
3315             loop->id = PropertyTagLoopCount;
3316             loop->length = sizeof(SHORT);
3317             loop->value = loop + 1;
3318             *(SHORT *)loop->value = 1;
3319         }
3320     }
3321
3322     if (delay) add_property(bitmap, delay);
3323     if (comment) add_property(bitmap, comment);
3324     if (loop) add_property(bitmap, loop);
3325     if (palette) add_property(bitmap, palette);
3326     if (background) add_property(bitmap, background);
3327
3328     heap_free(delay);
3329     heap_free(comment);
3330     heap_free(loop);
3331     heap_free(palette);
3332     heap_free(background);
3333
3334     /* Win7 gdiplus always returns transparent color index from frame 0 */
3335     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
3336     if (hr != S_OK) return;
3337
3338     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3339     if (hr == S_OK)
3340     {
3341         hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3342         if (hr == S_OK)
3343         {
3344             for (i = 0; i < block_count; i++)
3345             {
3346                 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3347                 if (hr == S_OK)
3348                 {
3349                     if (!transparent_idx)
3350                         transparent_idx = get_gif_transparent_idx(reader);
3351
3352                     IWICMetadataReader_Release(reader);
3353                 }
3354             }
3355         }
3356         IWICMetadataBlockReader_Release(block_reader);
3357     }
3358
3359     if (transparent_idx) add_property(bitmap, transparent_idx);
3360     heap_free(transparent_idx);
3361
3362     IWICBitmapFrameDecode_Release(frame);
3363 }
3364
3365 static PropertyItem* create_prop(PROPID propid, PROPVARIANT* value)
3366 {
3367     PropertyItem *item = NULL;
3368     UINT item_size = propvariant_size(value);
3369
3370     if (item_size)
3371     {
3372         item_size += sizeof(*item);
3373         item = heap_alloc_zero(item_size);
3374         if (propvariant_to_item(value, item, item_size, propid) != Ok)
3375         {
3376             heap_free(item);
3377             item = NULL;
3378         }
3379     }
3380
3381     return item;
3382 }
3383
3384 static ULONG get_ulong_by_index(IWICMetadataReader* reader, ULONG index)
3385 {
3386     PROPVARIANT value;
3387     HRESULT hr;
3388     ULONG result=0;
3389
3390     hr = IWICMetadataReader_GetValueByIndex(reader, index, NULL, NULL, &value);
3391     if (SUCCEEDED(hr))
3392     {
3393         switch (value.vt)
3394         {
3395         case VT_UI4:
3396             result = value.u.ulVal;
3397             break;
3398         default:
3399             ERR("unhandled case %u\n", value.vt);
3400             break;
3401         }
3402         PropVariantClear(&value);
3403     }
3404     return result;
3405 }
3406
3407 static void png_metadata_reader(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT active_frame)
3408 {
3409     HRESULT hr;
3410     IWICBitmapFrameDecode *frame;
3411     IWICMetadataBlockReader *block_reader;
3412     IWICMetadataReader *reader;
3413     UINT block_count, i, j;
3414     struct keyword_info {
3415         const char* name;
3416         PROPID propid;
3417         BOOL seen;
3418     } keywords[] = {
3419         { "Title", PropertyTagImageTitle },
3420         { "Author", PropertyTagArtist },
3421         { "Description", PropertyTagImageDescription },
3422         { "Copyright", PropertyTagCopyright },
3423         { "Software", PropertyTagSoftwareUsed },
3424         { "Source", PropertyTagEquipModel },
3425         { "Comment", PropertyTagExifUserComment },
3426     };
3427     BOOL seen_gamma=FALSE, seen_whitepoint=FALSE, seen_chrm=FALSE;
3428
3429     hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
3430     if (hr != S_OK) return;
3431
3432     hr = IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader);
3433     if (hr == S_OK)
3434     {
3435         hr = IWICMetadataBlockReader_GetCount(block_reader, &block_count);
3436         if (hr == S_OK)
3437         {
3438             for (i = 0; i < block_count; i++)
3439             {
3440                 hr = IWICMetadataBlockReader_GetReaderByIndex(block_reader, i, &reader);
3441                 if (hr == S_OK)
3442                 {
3443                     GUID format;
3444
3445                     hr = IWICMetadataReader_GetMetadataFormat(reader, &format);
3446                     if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunktEXt, &format))
3447                     {
3448                         PROPVARIANT name, value;
3449                         PropertyItem* item;
3450
3451                         hr = IWICMetadataReader_GetValueByIndex(reader, 0, NULL, &name, &value);
3452
3453                         if (SUCCEEDED(hr))
3454                         {
3455                             if (name.vt == VT_LPSTR)
3456                             {
3457                                 for (j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++)
3458                                     if (!strcmp(keywords[j].name, name.u.pszVal))
3459                                         break;
3460                                 if (j < sizeof(keywords)/sizeof(keywords[0]) && !keywords[j].seen)
3461                                 {
3462                                     keywords[j].seen = TRUE;
3463                                     item = create_prop(keywords[j].propid, &value);
3464                                     if (item)
3465                                         add_property(bitmap, item);
3466                                     heap_free(item);
3467                                 }
3468                             }
3469
3470                             PropVariantClear(&name);
3471                             PropVariantClear(&value);
3472                         }
3473                     }
3474                     else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkgAMA, &format))
3475                     {
3476                         PropertyItem* item;
3477
3478                         if (!seen_gamma)
3479                         {
3480                             item = heap_alloc_zero(sizeof(PropertyItem) + sizeof(ULONG) * 2);
3481                             if (item)
3482                             {
3483                                 ULONG *rational;
3484                                 item->length = sizeof(ULONG) * 2;
3485                                 item->type = PropertyTagTypeRational;
3486                                 item->id = PropertyTagGamma;
3487                                 rational = item->value = item + 1;
3488                                 rational[0] = 100000;
3489                                 rational[1] = get_ulong_by_index(reader, 0);
3490                                 add_property(bitmap, item);
3491                                 seen_gamma = TRUE;
3492                                 heap_free(item);
3493                             }
3494                         }
3495                     }
3496                     else if (SUCCEEDED(hr) && IsEqualGUID(&GUID_MetadataFormatChunkcHRM, &format))
3497                     {
3498                         PropertyItem* item;
3499
3500                         if (!seen_whitepoint)
3501                         {
3502                             item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 4);
3503                             if (item)
3504                             {
3505                                 ULONG *rational;
3506                                 item->length = sizeof(ULONG) * 4;
3507                                 item->type = PropertyTagTypeRational;
3508                                 item->id = PropertyTagWhitePoint;
3509                                 rational = item->value = item + 1;
3510                                 rational[0] = get_ulong_by_index(reader, 0);
3511                                 rational[1] = 100000;
3512                                 rational[2] = get_ulong_by_index(reader, 1);
3513                                 rational[3] = 100000;
3514                                 add_property(bitmap, item);
3515                                 seen_whitepoint = TRUE;
3516                                 GdipFree(item);
3517                             }
3518                         }
3519                         if (!seen_chrm)
3520                         {
3521                             item = GdipAlloc(sizeof(PropertyItem) + sizeof(ULONG) * 12);
3522                             if (item)
3523                             {
3524                                 ULONG *rational;
3525                                 item->length = sizeof(ULONG) * 12;
3526                                 item->type = PropertyTagTypeRational;
3527                                 item->id = PropertyTagPrimaryChromaticities;
3528                                 rational = item->value = item + 1;
3529                                 rational[0] = get_ulong_by_index(reader, 2);
3530                                 rational[1] = 100000;
3531                                 rational[2] = get_ulong_by_index(reader, 3);
3532                                 rational[3] = 100000;
3533                                 rational[4] = get_ulong_by_index(reader, 4);
3534                                 rational[5] = 100000;
3535                                 rational[6] = get_ulong_by_index(reader, 5);
3536                                 rational[7] = 100000;
3537                                 rational[8] = get_ulong_by_index(reader, 6);
3538                                 rational[9] = 100000;
3539                                 rational[10] = get_ulong_by_index(reader, 7);
3540                                 rational[11] = 100000;
3541                                 add_property(bitmap, item);
3542                                 seen_chrm = TRUE;
3543                                 GdipFree(item);
3544                             }
3545                         }
3546                     }
3547
3548                     IWICMetadataReader_Release(reader);
3549                 }
3550             }
3551         }
3552         IWICMetadataBlockReader_Release(block_reader);
3553     }
3554
3555     IWICBitmapFrameDecode_Release(frame);
3556 }
3557
3558 static GpStatus initialize_decoder_wic(IStream *stream, REFGUID container, IWICBitmapDecoder **decoder)
3559 {
3560     IWICImagingFactory *factory;
3561     HRESULT hr;
3562
3563     TRACE("%p,%s\n", stream, wine_dbgstr_guid(container));
3564
3565     hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
3566     if (FAILED(hr)) return hresult_to_status(hr);
3567     hr = IWICImagingFactory_CreateDecoder(factory, container, NULL, decoder);
3568     IWICImagingFactory_Release(factory);
3569     if (FAILED(hr)) return hresult_to_status(hr);
3570
3571     hr = IWICBitmapDecoder_Initialize(*decoder, stream, WICDecodeMetadataCacheOnLoad);
3572     if (FAILED(hr)) return hresult_to_status(hr);
3573     return Ok;
3574 }
3575
3576 typedef void (*metadata_reader_func)(GpBitmap *bitmap, IWICBitmapDecoder *decoder, UINT frame);
3577
3578 static GpStatus decode_frame_wic(IWICBitmapDecoder *decoder, BOOL force_conversion,
3579     UINT active_frame, metadata_reader_func metadata_reader, GpImage **image)
3580 {
3581     GpStatus status=Ok;
3582     GpBitmap *bitmap;
3583     HRESULT hr;
3584     IWICBitmapFrameDecode *frame;
3585     IWICBitmapSource *source=NULL;
3586     IWICMetadataBlockReader *block_reader;
3587     WICPixelFormatGUID wic_format;
3588     PixelFormat gdip_format=0;
3589     ColorPalette *palette = NULL;
3590     WICBitmapPaletteType palette_type = WICBitmapPaletteTypeFixedHalftone256;
3591     int i;
3592     UINT width, height, frame_count;
3593     BitmapData lockeddata;
3594     WICRect wrc;
3595
3596     TRACE("%p,%u,%p\n", decoder, active_frame, image);
3597
3598     IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3599     hr = IWICBitmapDecoder_GetFrame(decoder, active_frame, &frame);
3600     if (SUCCEEDED(hr)) /* got frame */
3601     {
3602         hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &wic_format);
3603
3604         if (SUCCEEDED(hr))
3605         {
3606             if (!force_conversion)
3607             {
3608                 for (i=0; pixel_formats[i].wic_format; i++)
3609                 {
3610                     if (IsEqualGUID(&wic_format, pixel_formats[i].wic_format))
3611                     {
3612                         source = (IWICBitmapSource*)frame;
3613                         IWICBitmapSource_AddRef(source);
3614                         gdip_format = pixel_formats[i].gdip_format;
3615                         palette_type = pixel_formats[i].palette_type;
3616                         break;
3617                     }
3618                 }
3619             }
3620             if (!source)
3621             {
3622                 /* unknown format; fall back on 32bppARGB */
3623                 hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
3624                 gdip_format = PixelFormat32bppARGB;
3625             }
3626             TRACE("%s => %#x\n", wine_dbgstr_guid(&wic_format), gdip_format);
3627         }
3628
3629         if (SUCCEEDED(hr)) /* got source */
3630         {
3631             hr = IWICBitmapSource_GetSize(source, &width, &height);
3632
3633             if (SUCCEEDED(hr))
3634                 status = GdipCreateBitmapFromScan0(width, height, 0, gdip_format,
3635                     NULL, &bitmap);
3636
3637             if (SUCCEEDED(hr) && status == Ok) /* created bitmap */
3638             {
3639                 status = GdipBitmapLockBits(bitmap, NULL, ImageLockModeWrite,
3640                     gdip_format, &lockeddata);
3641                 if (status == Ok) /* locked bitmap */
3642                 {
3643                     wrc.X = 0;
3644                     wrc.Width = width;
3645                     wrc.Height = 1;
3646                     for (i=0; i<height; i++)
3647                     {
3648                         wrc.Y = i;
3649                         hr = IWICBitmapSource_CopyPixels(source, &wrc, abs(lockeddata.Stride),
3650                             abs(lockeddata.Stride), (BYTE*)lockeddata.Scan0+lockeddata.Stride*i);
3651                         if (FAILED(hr)) break;
3652                     }
3653
3654                     GdipBitmapUnlockBits(bitmap, &lockeddata);
3655                 }
3656
3657                 if (SUCCEEDED(hr) && status == Ok)
3658                     *image = &bitmap->image;
3659                 else
3660                 {
3661                     *image = NULL;
3662                     GdipDisposeImage(&bitmap->image);
3663                 }
3664
3665                 if (SUCCEEDED(hr) && status == Ok)
3666                 {
3667                     double dpix, dpiy;
3668                     hr = IWICBitmapSource_GetResolution(source, &dpix, &dpiy);
3669                     if (SUCCEEDED(hr))
3670                     {
3671                         bitmap->image.xres = dpix;
3672                         bitmap->image.yres = dpiy;
3673                     }
3674                     hr = S_OK;
3675                 }
3676             }
3677
3678             IWICBitmapSource_Release(source);
3679         }
3680
3681         if (SUCCEEDED(hr)) {
3682             bitmap->metadata_reader = NULL;
3683
3684             if (metadata_reader)
3685                 metadata_reader(bitmap, decoder, active_frame);
3686             else if (IWICBitmapFrameDecode_QueryInterface(frame, &IID_IWICMetadataBlockReader, (void **)&block_reader) == S_OK)
3687             {
3688                 UINT block_count = 0;
3689                 if (IWICMetadataBlockReader_GetCount(block_reader, &block_count) == S_OK && block_count)
3690                     IWICMetadataBlockReader_GetReaderByIndex(block_reader, 0, &bitmap->metadata_reader);
3691                 IWICMetadataBlockReader_Release(block_reader);
3692             }
3693
3694             palette = get_palette(frame, palette_type);
3695             IWICBitmapFrameDecode_Release(frame);
3696         }
3697     }
3698
3699     if (FAILED(hr) && status == Ok) status = hresult_to_status(hr);
3700
3701     if (status == Ok)
3702     {
3703         /* Native GDI+ used to be smarter, but since Win7 it just sets these flags. */
3704         bitmap->image.flags |= ImageFlagsReadOnly|ImageFlagsHasRealPixelSize|ImageFlagsHasRealDPI;
3705         if (IsEqualGUID(&wic_format, &GUID_WICPixelFormat2bppGray) ||
3706             IsEqualGUID(&wic_format, &GUID_WICPixelFormat4bppGray) ||
3707             IsEqualGUID(&wic_format, &GUID_WICPixelFormat8bppGray) ||
3708             IsEqualGUID(&wic_format, &GUID_WICPixelFormat16bppGray))
3709             bitmap->image.flags |= ImageFlagsColorSpaceGRAY;
3710         else
3711             bitmap->image.flags |= ImageFlagsColorSpaceRGB;
3712         bitmap->image.frame_count = frame_count;
3713         bitmap->image.current_frame = active_frame;
3714         bitmap->image.decoder = decoder;
3715         IWICBitmapDecoder_AddRef(decoder);
3716         if (palette)
3717         {
3718             heap_free(bitmap->image.palette);
3719             bitmap->image.palette = palette;
3720         }
3721         else
3722         {
3723             if (IsEqualGUID(&wic_format, &GUID_WICPixelFormatBlackWhite))
3724                 bitmap->image.palette->Flags = 0;
3725         }
3726         TRACE("=> %p\n", *image);
3727     }
3728
3729     return status;
3730 }
3731
3732 static GpStatus decode_image_wic(IStream *stream, REFGUID container,
3733         metadata_reader_func metadata_reader, GpImage **image)
3734 {
3735     IWICBitmapDecoder *decoder;
3736     GpStatus status;
3737
3738     status = initialize_decoder_wic(stream, container, &decoder);
3739     if(status != Ok)
3740         return status;
3741
3742     status = decode_frame_wic(decoder, FALSE, 0, metadata_reader, image);
3743     IWICBitmapDecoder_Release(decoder);
3744     return status;
3745 }
3746
3747 static GpStatus select_frame_wic(GpImage *image, UINT active_frame)
3748 {
3749     GpImage *new_image;
3750     GpStatus status;
3751
3752     status = decode_frame_wic(image->decoder, FALSE, active_frame, NULL, &new_image);
3753     if(status != Ok)
3754         return status;
3755
3756     new_image->busy = image->busy;
3757     memcpy(&new_image->format, &image->format, sizeof(GUID));
3758     free_image_data(image);
3759     if (image->type == ImageTypeBitmap)
3760         *(GpBitmap *)image = *(GpBitmap *)new_image;
3761     else if (image->type == ImageTypeMetafile)
3762         *(GpMetafile *)image = *(GpMetafile *)new_image;
3763     new_image->type = ~0;
3764     heap_free(new_image);
3765     return Ok;
3766 }
3767
3768 static HRESULT get_gif_frame_rect(IWICBitmapFrameDecode *frame,
3769         UINT *left, UINT *top, UINT *width, UINT *height)
3770 {
3771     static const WCHAR leftW[] = {'L','e','f','t',0};
3772     static const WCHAR topW[] = {'T','o','p',0};
3773
3774     *left = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, leftW);
3775     *top = get_gif_frame_property(frame, &GUID_MetadataFormatIMD, topW);
3776
3777     return IWICBitmapFrameDecode_GetSize(frame, width, height);
3778 }
3779
3780 static HRESULT blit_gif_frame(GpBitmap *bitmap, IWICBitmapFrameDecode *frame, BOOL first_frame)
3781 {
3782     UINT i, j, left, top, width, height;
3783     IWICBitmapSource *source;
3784     BYTE *new_bits;
3785     HRESULT hr;
3786
3787     hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
3788     if(FAILED(hr))
3789         return hr;
3790
3791     hr = WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA, (IWICBitmapSource*)frame, &source);
3792     if(FAILED(hr))
3793         return hr;
3794
3795     new_bits = heap_alloc_zero(width*height*4);
3796     if(!new_bits)
3797         return E_OUTOFMEMORY;
3798
3799     hr = IWICBitmapSource_CopyPixels(source, NULL, width*4, width*height*4, new_bits);
3800     IWICBitmapSource_Release(source);
3801     if(FAILED(hr)) {
3802         heap_free(new_bits);
3803         return hr;
3804     }
3805
3806     for(i=0; i<height && i+top<bitmap->height; i++) {
3807         for(j=0; j<width && j+left<bitmap->width; j++) {
3808             DWORD *src = (DWORD*)(new_bits+i*width*4+j*4);
3809             DWORD *dst = (DWORD*)(bitmap->bits+(i+top)*bitmap->stride+(j+left)*4);
3810
3811             if(first_frame || *src>>24 != 0)
3812                 *dst = *src;
3813         }
3814     }
3815     heap_free(new_bits);
3816     return hr;
3817 }
3818
3819 static DWORD get_gif_background_color(GpBitmap *bitmap)
3820 {
3821     BYTE bgcolor_idx = 0;
3822     UINT i;
3823
3824     for(i=0; i<bitmap->prop_count; i++) {
3825         if(bitmap->prop_item[i].id == PropertyTagIndexBackground) {
3826             bgcolor_idx = *(BYTE*)bitmap->prop_item[i].value;
3827             break;
3828         }
3829     }
3830
3831     for(i=0; i<bitmap->prop_count; i++) {
3832         if(bitmap->prop_item[i].id == PropertyTagIndexTransparent) {
3833             BYTE transparent_idx;
3834             transparent_idx = *(BYTE*)bitmap->prop_item[i].value;
3835
3836             if(transparent_idx == bgcolor_idx)
3837                 return 0;
3838         }
3839     }
3840
3841     for(i=0; i<bitmap->prop_count; i++) {
3842         if(bitmap->prop_item[i].id == PropertyTagGlobalPalette) {
3843             if(bitmap->prop_item[i].length/3 > bgcolor_idx) {
3844                 BYTE *color = ((BYTE*)bitmap->prop_item[i].value)+bgcolor_idx*3;
3845                 return color[2] + (color[1]<<8) + (color[0]<<16) + (0xffu<<24);
3846             }
3847             break;
3848         }
3849     }
3850
3851     FIXME("can't get gif background color\n");
3852     return 0xffffffff;
3853 }
3854
3855 static GpStatus select_frame_gif(GpImage* image, UINT active_frame)
3856 {
3857     static const WCHAR disposalW[] = {'D','i','s','p','o','s','a','l',0};
3858
3859     GpBitmap *bitmap = (GpBitmap*)image;
3860     IWICBitmapFrameDecode *frame;
3861     int cur_frame=0, disposal;
3862     BOOL bgcolor_set = FALSE;
3863     DWORD bgcolor = 0;
3864     HRESULT hr;
3865
3866     if(active_frame > image->current_frame) {
3867         hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, image->current_frame, &frame);
3868         if(FAILED(hr))
3869             return hresult_to_status(hr);
3870         disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
3871         IWICBitmapFrameDecode_Release(frame);
3872
3873         if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND)
3874             cur_frame = image->current_frame;
3875         else if(disposal != GIF_DISPOSE_RESTORE_TO_PREV)
3876             cur_frame = image->current_frame+1;
3877     }
3878
3879     while(cur_frame != active_frame) {
3880         hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, cur_frame, &frame);
3881         if(FAILED(hr))
3882             return hresult_to_status(hr);
3883         disposal = get_gif_frame_property(frame, &GUID_MetadataFormatGCE, disposalW);
3884
3885         if(disposal==GIF_DISPOSE_UNSPECIFIED || disposal==GIF_DISPOSE_DO_NOT_DISPOSE) {
3886             hr = blit_gif_frame(bitmap, frame, cur_frame==0);
3887             if(FAILED(hr))
3888                 return hresult_to_status(hr);
3889         }else if(disposal == GIF_DISPOSE_RESTORE_TO_BKGND) {
3890             UINT left, top, width, height, i, j;
3891
3892             if(!bgcolor_set) {
3893                 bgcolor = get_gif_background_color(bitmap);
3894                 bgcolor_set = TRUE;
3895             }
3896
3897             hr = get_gif_frame_rect(frame, &left, &top, &width, &height);
3898             if(FAILED(hr))
3899                 return hresult_to_status(hr);
3900             for(i=top; i<top+height && i<bitmap->height; i++) {
3901                 DWORD *bits = (DWORD*)(bitmap->bits+i*bitmap->stride);
3902                 for(j=left; j<left+width && j<bitmap->width; j++)
3903                     bits[j] = bgcolor;
3904             }
3905         }
3906
3907         IWICBitmapFrameDecode_Release(frame);
3908         cur_frame++;
3909     }
3910
3911     hr = IWICBitmapDecoder_GetFrame(bitmap->image.decoder, active_frame, &frame);
3912     if(FAILED(hr))
3913         return hresult_to_status(hr);
3914
3915     hr = blit_gif_frame(bitmap, frame, cur_frame==0);
3916     IWICBitmapFrameDecode_Release(frame);
3917     if(FAILED(hr))
3918         return hresult_to_status(hr);
3919
3920     image->current_frame = active_frame;
3921     return Ok;
3922 }
3923
3924 static GpStatus decode_image_icon(IStream* stream, GpImage **image)
3925 {
3926     return decode_image_wic(stream, &GUID_ContainerFormatIco, NULL, image);
3927 }
3928
3929 static GpStatus decode_image_bmp(IStream* stream, GpImage **image)
3930 {
3931     GpStatus status;
3932     GpBitmap* bitmap;
3933
3934     status = decode_image_wic(stream, &GUID_ContainerFormatBmp, NULL, image);
3935
3936     bitmap = (GpBitmap*)*image;
3937
3938     if (status == Ok && bitmap->format == PixelFormat32bppARGB)
3939     {
3940         /* WIC supports bmp files with alpha, but gdiplus does not */
3941         bitmap->format = PixelFormat32bppRGB;
3942     }
3943
3944     return status;
3945 }
3946
3947 static GpStatus decode_image_jpeg(IStream* stream, GpImage **image)
3948 {
3949     return decode_image_wic(stream, &GUID_ContainerFormatJpeg, NULL, image);
3950 }
3951
3952 static GpStatus decode_image_png(IStream* stream, GpImage **image)
3953 {
3954     IWICBitmapDecoder *decoder;
3955     IWICBitmapFrameDecode *frame;
3956     GpStatus status;
3957     HRESULT hr;
3958     GUID format;
3959     BOOL force_conversion = FALSE;
3960
3961     status = initialize_decoder_wic(stream, &GUID_ContainerFormatPng, &decoder);
3962     if (status != Ok)
3963         return status;
3964
3965     hr = IWICBitmapDecoder_GetFrame(decoder, 0, &frame);
3966     if (hr == S_OK)
3967     {
3968         hr = IWICBitmapFrameDecode_GetPixelFormat(frame, &format);
3969         if (hr == S_OK)
3970         {
3971             if (IsEqualGUID(&format, &GUID_WICPixelFormat8bppGray))
3972                 force_conversion = TRUE;
3973             status = decode_frame_wic(decoder, force_conversion, 0, png_metadata_reader, image);
3974         }
3975         else
3976             status = hresult_to_status(hr);
3977
3978         IWICBitmapFrameDecode_Release(frame);
3979     }
3980     else
3981         status = hresult_to_status(hr);
3982
3983     IWICBitmapDecoder_Release(decoder);
3984     return status;
3985 }
3986
3987 static GpStatus decode_image_gif(IStream* stream, GpImage **image)
3988 {
3989     IWICBitmapDecoder *decoder;
3990     UINT frame_count;
3991     GpStatus status;
3992     HRESULT hr;
3993
3994     status = initialize_decoder_wic(stream, &GUID_ContainerFormatGif, &decoder);
3995     if(status != Ok)
3996         return status;
3997
3998     hr = IWICBitmapDecoder_GetFrameCount(decoder, &frame_count);
3999     if(FAILED(hr))
4000         return hresult_to_status(hr);
4001
4002     status = decode_frame_wic(decoder, frame_count > 1, 0, gif_metadata_reader, image);
4003     IWICBitmapDecoder_Release(decoder);
4004     if(status != Ok)
4005         return status;
4006
4007     if(frame_count > 1) {
4008         heap_free((*image)->palette);
4009         (*image)->palette = NULL;
4010     }
4011     return Ok;
4012 }
4013
4014 static GpStatus decode_image_tiff(IStream* stream, GpImage **image)
4015 {
4016     return decode_image_wic(stream, &GUID_ContainerFormatTiff, NULL, image);
4017 }
4018
4019 static GpStatus load_wmf(IStream *stream, GpMetafile **metafile)
4020 {
4021     WmfPlaceableFileHeader pfh;
4022     BOOL is_placeable = FALSE;
4023     LARGE_INTEGER seek;
4024     GpStatus status;
4025     METAHEADER mh;
4026     HMETAFILE hmf;
4027     HRESULT hr;
4028     UINT size;
4029     void *buf;
4030
4031     hr = IStream_Read(stream, &mh, sizeof(mh), &size);
4032     if (hr != S_OK || size != sizeof(mh))
4033         return GenericError;
4034
4035     if (((WmfPlaceableFileHeader *)&mh)->Key == WMF_PLACEABLE_KEY)
4036     {
4037         seek.QuadPart = 0;
4038         hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4039         if (FAILED(hr)) return hresult_to_status(hr);
4040
4041         hr = IStream_Read(stream, &pfh, sizeof(pfh), &size);
4042         if (hr != S_OK || size != sizeof(pfh))
4043             return GenericError;
4044
4045         hr = IStream_Read(stream, &mh, sizeof(mh), &size);
4046         if (hr != S_OK || size != sizeof(mh))
4047             return GenericError;
4048
4049         is_placeable = TRUE;
4050     }
4051
4052     seek.QuadPart = is_placeable ? sizeof(pfh) : 0;
4053     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4054     if (FAILED(hr)) return hresult_to_status(hr);
4055
4056     buf = heap_alloc(mh.mtSize * 2);
4057     if (!buf) return OutOfMemory;
4058
4059     hr = IStream_Read(stream, buf, mh.mtSize * 2, &size);
4060     if (hr != S_OK || size != mh.mtSize * 2)
4061     {
4062         heap_free(buf);
4063         return GenericError;
4064     }
4065
4066     hmf = SetMetaFileBitsEx(mh.mtSize * 2, buf);
4067     heap_free(buf);
4068     if (!hmf)
4069         return GenericError;
4070
4071     status = GdipCreateMetafileFromWmf(hmf, TRUE, is_placeable ? &pfh : NULL, metafile);
4072     if (status != Ok)
4073         DeleteMetaFile(hmf);
4074     return status;
4075 }
4076
4077 static GpStatus decode_image_wmf(IStream *stream, GpImage **image)
4078 {
4079     GpMetafile *metafile;
4080     GpStatus status;
4081
4082     TRACE("%p %p\n", stream, image);
4083
4084     if (!stream || !image)
4085         return InvalidParameter;
4086
4087     status = load_wmf(stream, &metafile);
4088     if (status != Ok)
4089     {
4090         TRACE("Could not load metafile\n");
4091         return status;
4092     }
4093
4094     *image = (GpImage *)metafile;
4095     TRACE("<-- %p\n", *image);
4096
4097     return Ok;
4098 }
4099
4100 static GpStatus load_emf(IStream *stream, GpMetafile **metafile)
4101 {
4102     LARGE_INTEGER seek;
4103     ENHMETAHEADER emh;
4104     HENHMETAFILE hemf;
4105     GpStatus status;
4106     HRESULT hr;
4107     UINT size;
4108     void *buf;
4109
4110     hr = IStream_Read(stream, &emh, sizeof(emh), &size);
4111     if (hr != S_OK || size != sizeof(emh) || emh.dSignature != ENHMETA_SIGNATURE)
4112         return GenericError;
4113
4114     seek.QuadPart = 0;
4115     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4116     if (FAILED(hr)) return hresult_to_status(hr);
4117
4118     buf = heap_alloc(emh.nBytes);
4119     if (!buf) return OutOfMemory;
4120
4121     hr = IStream_Read(stream, buf, emh.nBytes, &size);
4122     if (hr != S_OK || size != emh.nBytes)
4123     {
4124         heap_free(buf);
4125         return GenericError;
4126     }
4127
4128     hemf = SetEnhMetaFileBits(emh.nBytes, buf);
4129     heap_free(buf);
4130     if (!hemf)
4131         return GenericError;
4132
4133     status = GdipCreateMetafileFromEmf(hemf, TRUE, metafile);
4134     if (status != Ok)
4135         DeleteEnhMetaFile(hemf);
4136     return status;
4137 }
4138
4139 static GpStatus decode_image_emf(IStream *stream, GpImage **image)
4140 {
4141     GpMetafile *metafile;
4142     GpStatus status;
4143
4144     TRACE("%p %p\n", stream, image);
4145
4146     if (!stream || !image)
4147         return InvalidParameter;
4148
4149     status = load_emf(stream, &metafile);
4150     if (status != Ok)
4151     {
4152         TRACE("Could not load metafile\n");
4153         return status;
4154     }
4155
4156     *image = (GpImage *)metafile;
4157     TRACE("<-- %p\n", *image);
4158
4159     return Ok;
4160 }
4161
4162 typedef GpStatus (*encode_image_func)(GpImage *image, IStream* stream,
4163     GDIPCONST EncoderParameters* params);
4164
4165 typedef GpStatus (*decode_image_func)(IStream *stream, GpImage **image);
4166
4167 typedef GpStatus (*select_image_func)(GpImage *image, UINT active_frame);
4168
4169 typedef struct image_codec {
4170     ImageCodecInfo info;
4171     encode_image_func encode_func;
4172     decode_image_func decode_func;
4173     select_image_func select_func;
4174 } image_codec;
4175
4176 typedef enum {
4177     BMP,
4178     JPEG,
4179     GIF,
4180     TIFF,
4181     EMF,
4182     WMF,
4183     PNG,
4184     ICO,
4185     NUM_CODECS
4186 } ImageFormat;
4187
4188 static const struct image_codec codecs[NUM_CODECS];
4189
4190 static GpStatus get_decoder_info(IStream* stream, const struct image_codec **result)
4191 {
4192     BYTE signature[8];
4193     const BYTE *pattern, *mask;
4194     LARGE_INTEGER seek;
4195     HRESULT hr;
4196     UINT bytesread;
4197     int i;
4198     DWORD j, sig;
4199
4200     /* seek to the start of the stream */
4201     seek.QuadPart = 0;
4202     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4203     if (FAILED(hr)) return hresult_to_status(hr);
4204
4205     /* read the first 8 bytes */
4206     /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
4207     hr = IStream_Read(stream, signature, 8, &bytesread);
4208     if (FAILED(hr)) return hresult_to_status(hr);
4209     if (hr == S_FALSE || bytesread == 0) return GenericError;
4210
4211     for (i = 0; i < NUM_CODECS; i++) {
4212         if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
4213             bytesread >= codecs[i].info.SigSize)
4214         {
4215             for (sig=0; sig<codecs[i].info.SigCount; sig++)
4216             {
4217                 pattern = &codecs[i].info.SigPattern[codecs[i].info.SigSize*sig];
4218                 mask = &codecs[i].info.SigMask[codecs[i].info.SigSize*sig];
4219                 for (j=0; j<codecs[i].info.SigSize; j++)
4220                     if ((signature[j] & mask[j]) != pattern[j])
4221                         break;
4222                 if (j == codecs[i].info.SigSize)
4223                 {
4224                     *result = &codecs[i];
4225                     return Ok;
4226                 }
4227             }
4228         }
4229     }
4230
4231     TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread,
4232         signature[0],signature[1],signature[2],signature[3],
4233         signature[4],signature[5],signature[6],signature[7]);
4234
4235     return GenericError;
4236 }
4237
4238 static GpStatus get_decoder_info_from_image(GpImage *image, const struct image_codec **result)
4239 {
4240     int i;
4241
4242     for (i = 0; i < NUM_CODECS; i++) {
4243         if ((codecs[i].info.Flags & ImageCodecFlagsDecoder) &&
4244                 IsEqualIID(&codecs[i].info.FormatID, &image->format))
4245         {
4246             *result = &codecs[i];
4247             return Ok;
4248         }
4249     }
4250
4251     TRACE("no match for format: %s\n", wine_dbgstr_guid(&image->format));
4252     return GenericError;
4253 }
4254
4255 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image, GDIPCONST GUID *dimensionID,
4256                                                UINT frame)
4257 {
4258     GpStatus stat;
4259     const struct image_codec *codec = NULL;
4260     BOOL unlock;
4261
4262     TRACE("(%p,%s,%u)\n", image, debugstr_guid(dimensionID), frame);
4263
4264     if (!image || !dimensionID)
4265         return InvalidParameter;
4266     if(!image_lock(image, &unlock))
4267         return ObjectBusy;
4268
4269     if (frame >= image->frame_count)
4270     {
4271         WARN("requested frame %u, but image has only %u\n", frame, image->frame_count);
4272         image_unlock(image, unlock);
4273         return InvalidParameter;
4274     }
4275
4276     if (image->type != ImageTypeBitmap && image->type != ImageTypeMetafile)
4277     {
4278         WARN("invalid image type %d\n", image->type);
4279         image_unlock(image, unlock);
4280         return InvalidParameter;
4281     }
4282
4283     if (image->current_frame == frame)
4284     {
4285         image_unlock(image, unlock);
4286         return Ok;
4287     }
4288
4289     if (!image->decoder)
4290     {
4291         TRACE("image doesn't have an associated decoder\n");
4292         image_unlock(image, unlock);
4293         return Ok;
4294     }
4295
4296     /* choose an appropriate image decoder */
4297     stat = get_decoder_info_from_image(image, &codec);
4298     if (stat != Ok)
4299     {
4300         WARN("can't find decoder info\n");
4301         image_unlock(image, unlock);
4302         return stat;
4303     }
4304
4305     stat = codec->select_func(image, frame);
4306     image_unlock(image, unlock);
4307     return stat;
4308 }
4309
4310 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream *stream, GpImage **image)
4311 {
4312     GpStatus stat;
4313     LARGE_INTEGER seek;
4314     HRESULT hr;
4315     const struct image_codec *codec=NULL;
4316
4317     /* choose an appropriate image decoder */
4318     stat = get_decoder_info(stream, &codec);
4319     if (stat != Ok) return stat;
4320
4321     /* seek to the start of the stream */
4322     seek.QuadPart = 0;
4323     hr = IStream_Seek(stream, seek, STREAM_SEEK_SET, NULL);
4324     if (FAILED(hr)) return hresult_to_status(hr);
4325
4326     /* call on the image decoder to do the real work */
4327     stat = codec->decode_func(stream, image);
4328
4329     /* take note of the original data format */
4330     if (stat == Ok)
4331     {
4332         memcpy(&(*image)->format, &codec->info.FormatID, sizeof(GUID));
4333         return Ok;
4334     }
4335
4336     return stat;
4337 }
4338
4339 /* FIXME: no ICM */
4340 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
4341 {
4342     TRACE("%p %p\n", stream, image);
4343
4344     return GdipLoadImageFromStream(stream, image);
4345 }
4346
4347 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
4348 {
4349     static int calls;
4350
4351     TRACE("(%p,%u)\n", image, propId);
4352
4353     if(!image)
4354         return InvalidParameter;
4355
4356     if(!(calls++))
4357         FIXME("not implemented\n");
4358
4359     return NotImplemented;
4360 }
4361
4362 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
4363 {
4364     static int calls;
4365
4366     if (!image || !item) return InvalidParameter;
4367
4368     TRACE("(%p,%p:%#x,%u,%u,%p)\n", image, item, item->id, item->type, item->length, item->value);
4369
4370     if(!(calls++))
4371         FIXME("not implemented\n");
4372
4373     return Ok;
4374 }
4375
4376 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
4377                                         GDIPCONST CLSID *clsidEncoder,
4378                                         GDIPCONST EncoderParameters *encoderParams)
4379 {
4380     GpStatus stat;
4381     IStream *stream;
4382
4383     TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
4384
4385     if (!image || !filename|| !clsidEncoder)
4386         return InvalidParameter;
4387
4388     stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
4389     if (stat != Ok)
4390         return GenericError;
4391
4392     stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
4393
4394     IStream_Release(stream);
4395     return stat;
4396 }
4397
4398 /*************************************************************************
4399  * Encoding functions -
4400  *   These functions encode an image in different image file formats.
4401  */
4402
4403 static GpStatus encode_image_wic(GpImage *image, IStream* stream,
4404     REFGUID container, GDIPCONST EncoderParameters* params)
4405 {
4406     GpStatus stat;
4407     GpBitmap *bitmap;
4408     IWICImagingFactory *factory;
4409     IWICBitmapEncoder *encoder;
4410     IWICBitmapFrameEncode *frameencode;
4411     IPropertyBag2 *encoderoptions;
4412     HRESULT hr;
4413     UINT width, height;
4414     PixelFormat gdipformat=0;
4415     const WICPixelFormatGUID *desired_wicformat;
4416     WICPixelFormatGUID wicformat;
4417     GpRect rc;
4418     BitmapData lockeddata;
4419     UINT i;
4420
4421     if (image->type != ImageTypeBitmap)
4422         return GenericError;
4423
4424     bitmap = (GpBitmap*)image;
4425
4426     GdipGetImageWidth(image, &width);
4427     GdipGetImageHeight(image, &height);
4428
4429     rc.X = 0;
4430     rc.Y = 0;
4431     rc.Width = width;
4432     rc.Height = height;
4433
4434     hr = WICCreateImagingFactory_Proxy(WINCODEC_SDK_VERSION, &factory);
4435     if (FAILED(hr))
4436         return hresult_to_status(hr);
4437     hr = IWICImagingFactory_CreateEncoder(factory, container, NULL, &encoder);
4438     IWICImagingFactory_Release(factory);
4439     if (FAILED(hr))
4440         return hresult_to_status(hr);
4441
4442     hr = IWICBitmapEncoder_Initialize(encoder, stream, WICBitmapEncoderNoCache);
4443
4444     if (SUCCEEDED(hr))
4445     {
4446         hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frameencode, &encoderoptions);
4447     }
4448
4449     if (SUCCEEDED(hr)) /* created frame */
4450     {
4451         hr = IWICBitmapFrameEncode_Initialize(frameencode, encoderoptions);
4452
4453         if (SUCCEEDED(hr))
4454             hr = IWICBitmapFrameEncode_SetSize(frameencode, width, height);
4455
4456         if (SUCCEEDED(hr))
4457             hr = IWICBitmapFrameEncode_SetResolution(frameencode, image->xres, image->yres);
4458
4459         if (SUCCEEDED(hr))
4460         {
4461             for (i=0; pixel_formats[i].wic_format; i++)
4462             {
4463                 if (pixel_formats[i].gdip_format == bitmap->format)
4464                 {
4465                     desired_wicformat = pixel_formats[i].wic_format;
4466                     gdipformat = bitmap->format;
4467                     break;
4468                 }
4469             }
4470             if (!gdipformat)
4471             {
4472                 desired_wicformat = &GUID_WICPixelFormat32bppBGRA;
4473                 gdipformat = PixelFormat32bppARGB;
4474             }
4475
4476             memcpy(&wicformat, desired_wicformat, sizeof(GUID));
4477             hr = IWICBitmapFrameEncode_SetPixelFormat(frameencode, &wicformat);
4478         }
4479
4480         if (SUCCEEDED(hr) && !IsEqualGUID(desired_wicformat, &wicformat))
4481         {
4482             /* Encoder doesn't support this bitmap's format. */
4483             gdipformat = 0;
4484             for (i=0; pixel_formats[i].wic_format; i++)
4485             {
4486                 if (IsEqualGUID(&wicformat, pixel_formats[i].wic_format))
4487                 {
4488                     gdipformat = pixel_formats[i].gdip_format;
4489                     break;
4490                 }
4491             }
4492             if (!gdipformat)
4493             {
4494                 ERR("Cannot support encoder format %s\n", debugstr_guid(&wicformat));
4495                 hr = E_FAIL;
4496             }
4497         }
4498
4499         if (SUCCEEDED(hr))
4500         {
4501             stat = GdipBitmapLockBits(bitmap, &rc, ImageLockModeRead, gdipformat,
4502                 &lockeddata);
4503
4504             if (stat == Ok)
4505             {
4506                 UINT row_size = (lockeddata.Width * PIXELFORMATBPP(gdipformat) + 7)/8;
4507                 BYTE *row;
4508
4509                 /* write one row at a time in case stride is negative */
4510                 row = lockeddata.Scan0;
4511                 for (i=0; i<lockeddata.Height; i++)
4512                 {
4513                     hr = IWICBitmapFrameEncode_WritePixels(frameencode, 1, row_size, row_size, row);
4514                     if (FAILED(hr)) break;
4515                     row += lockeddata.Stride;
4516                 }
4517
4518                 GdipBitmapUnlockBits(bitmap, &lockeddata);
4519             }
4520             else
4521                 hr = E_FAIL;
4522         }
4523
4524         if (SUCCEEDED(hr))
4525             hr = IWICBitmapFrameEncode_Commit(frameencode);
4526
4527         IWICBitmapFrameEncode_Release(frameencode);
4528         IPropertyBag2_Release(encoderoptions);
4529     }
4530
4531     if (SUCCEEDED(hr))
4532         hr = IWICBitmapEncoder_Commit(encoder);
4533
4534     IWICBitmapEncoder_Release(encoder);
4535     return hresult_to_status(hr);
4536 }
4537
4538 static GpStatus encode_image_BMP(GpImage *image, IStream* stream,
4539     GDIPCONST EncoderParameters* params)
4540 {
4541     return encode_image_wic(image, stream, &GUID_ContainerFormatBmp, params);
4542 }
4543
4544 static GpStatus encode_image_tiff(GpImage *image, IStream* stream,
4545     GDIPCONST EncoderParameters* params)
4546 {
4547     return encode_image_wic(image, stream, &GUID_ContainerFormatTiff, params);
4548 }
4549
4550 GpStatus encode_image_png(GpImage *image, IStream* stream,
4551     GDIPCONST EncoderParameters* params)
4552 {
4553     return encode_image_wic(image, stream, &GUID_ContainerFormatPng, params);
4554 }
4555
4556 static GpStatus encode_image_jpeg(GpImage *image, IStream* stream,
4557     GDIPCONST EncoderParameters* params)
4558 {
4559     return encode_image_wic(image, stream, &GUID_ContainerFormatJpeg, params);
4560 }
4561
4562 static GpStatus encode_image_gif(GpImage *image, IStream* stream,
4563     GDIPCONST EncoderParameters* params)
4564 {
4565     return encode_image_wic(image, stream, &CLSID_WICGifEncoder, params);
4566 }
4567
4568 /*****************************************************************************
4569  * GdipSaveImageToStream [GDIPLUS.@]
4570  */
4571 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
4572     GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
4573 {
4574     GpStatus stat;
4575     encode_image_func encode_image;
4576     int i;
4577
4578     TRACE("%p %p %p %p\n", image, stream, clsid, params);
4579
4580     if(!image || !stream)
4581         return InvalidParameter;
4582
4583     /* select correct encoder */
4584     encode_image = NULL;
4585     for (i = 0; i < NUM_CODECS; i++) {
4586         if ((codecs[i].info.Flags & ImageCodecFlagsEncoder) &&
4587             IsEqualCLSID(clsid, &codecs[i].info.Clsid))
4588             encode_image = codecs[i].encode_func;
4589     }
4590     if (encode_image == NULL)
4591         return UnknownImageFormat;
4592
4593     stat = encode_image(image, stream, params);
4594
4595     return stat;
4596 }
4597
4598 /*****************************************************************************
4599  * GdipSaveAdd [GDIPLUS.@]
4600  */
4601 GpStatus WINGDIPAPI GdipSaveAdd(GpImage *image, GDIPCONST EncoderParameters *params)
4602 {
4603     FIXME("(%p,%p): stub\n", image, params);
4604     return Ok;
4605 }
4606
4607 /*****************************************************************************
4608  * GdipGetImagePalette [GDIPLUS.@]
4609  */
4610 GpStatus WINGDIPAPI GdipGetImagePalette(GpImage *image, ColorPalette *palette, INT size)
4611 {
4612     INT count;
4613
4614     TRACE("(%p,%p,%i)\n", image, palette, size);
4615
4616     if (!image || !palette)
4617         return InvalidParameter;
4618
4619     count = image->palette ? image->palette->Count : 0;
4620
4621     if (size < (sizeof(UINT)*2+sizeof(ARGB)*count))
4622     {
4623         TRACE("<-- InsufficientBuffer\n");
4624         return InsufficientBuffer;
4625     }
4626
4627     if (image->palette)
4628     {
4629         palette->Flags = image->palette->Flags;
4630         palette->Count = image->palette->Count;
4631         memcpy(palette->Entries, image->palette->Entries, sizeof(ARGB)*image->palette->Count);
4632     }
4633     else
4634     {
4635         palette->Flags = 0;
4636         palette->Count = 0;
4637     }
4638     return Ok;
4639 }
4640
4641 /*****************************************************************************
4642  * GdipSetImagePalette [GDIPLUS.@]
4643  */
4644 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
4645     GDIPCONST ColorPalette *palette)
4646 {
4647     ColorPalette *new_palette;
4648
4649     TRACE("(%p,%p)\n", image, palette);
4650
4651     if(!image || !palette || palette->Count > 256)
4652         return InvalidParameter;
4653
4654     new_palette = heap_alloc_zero(2 * sizeof(UINT) + palette->Count * sizeof(ARGB));
4655     if (!new_palette) return OutOfMemory;
4656
4657     heap_free(image->palette);
4658     image->palette = new_palette;
4659     image->palette->Flags = palette->Flags;
4660     image->palette->Count = palette->Count;
4661     memcpy(image->palette->Entries, palette->Entries, sizeof(ARGB)*palette->Count);
4662
4663     return Ok;
4664 }
4665
4666 /*************************************************************************
4667  * Encoders -
4668  *   Structures that represent which formats we support for encoding.
4669  */
4670
4671 /* ImageCodecInfo creation routines taken from libgdiplus */
4672 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
4673 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
4674 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
4675 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
4676 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
4677 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
4678
4679 static const WCHAR jpeg_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
4680 static const WCHAR jpeg_extension[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
4681 static const WCHAR jpeg_mimetype[] = {'i','m','a','g','e','/','j','p','e','g', 0};
4682 static const WCHAR jpeg_format[] = {'J','P','E','G',0};
4683 static const BYTE jpeg_sig_pattern[] = { 0xFF, 0xD8 };
4684 static const BYTE jpeg_sig_mask[] = { 0xFF, 0xFF };
4685
4686 static const WCHAR gif_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
4687 static const WCHAR gif_extension[] = {'*','.','G','I','F',0};
4688 static const WCHAR gif_mimetype[] = {'i','m','a','g','e','/','g','i','f', 0};
4689 static const WCHAR gif_format[] = {'G','I','F',0};
4690 static const BYTE gif_sig_pattern[12] = "GIF87aGIF89a";
4691 static const BYTE gif_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4692
4693 static const WCHAR tiff_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
4694 static const WCHAR tiff_extension[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
4695 static const WCHAR tiff_mimetype[] = {'i','m','a','g','e','/','t','i','f','f', 0};
4696 static const WCHAR tiff_format[] = {'T','I','F','F',0};
4697 static const BYTE tiff_sig_pattern[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
4698 static const BYTE tiff_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4699
4700 static const WCHAR emf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
4701 static const WCHAR emf_extension[] = {'*','.','E','M','F',0};
4702 static const WCHAR emf_mimetype[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
4703 static const WCHAR emf_format[] = {'E','M','F',0};
4704 static const BYTE emf_sig_pattern[] = { 0x01, 0x00, 0x00, 0x00 };
4705 static const BYTE emf_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
4706
4707 static const WCHAR wmf_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
4708 static const WCHAR wmf_extension[] = {'*','.','W','M','F',0};
4709 static const WCHAR wmf_mimetype[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
4710 static const WCHAR wmf_format[] = {'W','M','F',0};
4711 static const BYTE wmf_sig_pattern[] = { 0xd7, 0xcd };
4712 static const BYTE wmf_sig_mask[] = { 0xFF, 0xFF };
4713
4714 static const WCHAR png_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
4715 static const WCHAR png_extension[] = {'*','.','P','N','G',0};
4716 static const WCHAR png_mimetype[] = {'i','m','a','g','e','/','p','n','g', 0};
4717 static const WCHAR png_format[] = {'P','N','G',0};
4718 static const BYTE png_sig_pattern[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
4719 static const BYTE png_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
4720
4721 static const WCHAR ico_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
4722 static const WCHAR ico_extension[] = {'*','.','I','C','O',0};
4723 static const WCHAR ico_mimetype[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
4724 static const WCHAR ico_format[] = {'I','C','O',0};
4725 static const BYTE ico_sig_pattern[] = { 0x00, 0x00, 0x01, 0x00 };
4726 static const BYTE ico_sig_mask[] = { 0xFF, 0xFF, 0xFF, 0xFF };
4727
4728 static const struct image_codec codecs[NUM_CODECS] = {
4729     {
4730         { /* BMP */
4731             /* Clsid */              { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4732             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4733             /* CodecName */          bmp_codecname,
4734             /* DllName */            NULL,
4735             /* FormatDescription */  bmp_format,
4736             /* FilenameExtension */  bmp_extension,
4737             /* MimeType */           bmp_mimetype,
4738             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4739             /* Version */            1,
4740             /* SigCount */           1,
4741             /* SigSize */            2,
4742             /* SigPattern */         bmp_sig_pattern,
4743             /* SigMask */            bmp_sig_mask,
4744         },
4745         encode_image_BMP,
4746         decode_image_bmp,
4747         select_frame_wic
4748     },
4749     {
4750         { /* JPEG */
4751             /* Clsid */              { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4752             /* FormatID */           { 0xb96b3caeU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4753             /* CodecName */          jpeg_codecname,
4754             /* DllName */            NULL,
4755             /* FormatDescription */  jpeg_format,
4756             /* FilenameExtension */  jpeg_extension,
4757             /* MimeType */           jpeg_mimetype,
4758             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4759             /* Version */            1,
4760             /* SigCount */           1,
4761             /* SigSize */            2,
4762             /* SigPattern */         jpeg_sig_pattern,
4763             /* SigMask */            jpeg_sig_mask,
4764         },
4765         encode_image_jpeg,
4766         decode_image_jpeg,
4767         select_frame_wic
4768     },
4769     {
4770         { /* GIF */
4771             /* Clsid */              { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4772             /* FormatID */           { 0xb96b3cb0U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4773             /* CodecName */          gif_codecname,
4774             /* DllName */            NULL,
4775             /* FormatDescription */  gif_format,
4776             /* FilenameExtension */  gif_extension,
4777             /* MimeType */           gif_mimetype,
4778             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4779             /* Version */            1,
4780             /* SigCount */           2,
4781             /* SigSize */            6,
4782             /* SigPattern */         gif_sig_pattern,
4783             /* SigMask */            gif_sig_mask,
4784         },
4785         encode_image_gif,
4786         decode_image_gif,
4787         select_frame_gif
4788     },
4789     {
4790         { /* TIFF */
4791             /* Clsid */              { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4792             /* FormatID */           { 0xb96b3cb1U, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4793             /* CodecName */          tiff_codecname,
4794             /* DllName */            NULL,
4795             /* FormatDescription */  tiff_format,
4796             /* FilenameExtension */  tiff_extension,
4797             /* MimeType */           tiff_mimetype,
4798             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsEncoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4799             /* Version */            1,
4800             /* SigCount */           2,
4801             /* SigSize */            4,
4802             /* SigPattern */         tiff_sig_pattern,
4803             /* SigMask */            tiff_sig_mask,
4804         },
4805         encode_image_tiff,
4806         decode_image_tiff,
4807         select_frame_wic
4808     },
4809     {
4810         { /* EMF */
4811             /* Clsid */              { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4812             /* FormatID */           { 0xb96b3cacU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4813             /* CodecName */          emf_codecname,
4814             /* DllName */            NULL,
4815             /* FormatDescription */  emf_format,
4816             /* FilenameExtension */  emf_extension,
4817             /* MimeType */           emf_mimetype,
4818             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
4819             /* Version */            1,
4820             /* SigCount */           1,
4821             /* SigSize */            4,
4822             /* SigPattern */         emf_sig_pattern,
4823             /* SigMask */            emf_sig_mask,
4824         },
4825         NULL,
4826         decode_image_emf,
4827         NULL
4828     },
4829     {
4830         { /* WMF */
4831             /* Clsid */              { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4832             /* FormatID */           { 0xb96b3cadU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4833             /* CodecName */          wmf_codecname,
4834             /* DllName */            NULL,
4835             /* FormatDescription */  wmf_format,
4836             /* FilenameExtension */  wmf_extension,
4837             /* MimeType */           wmf_mimetype,
4838             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportVector | ImageCodecFlagsBuiltin,
4839             /* Version */            1,
4840             /* SigCount */           1,
4841             /* SigSize */            2,
4842             /* SigPattern */         wmf_sig_pattern,
4843             /* SigMask */            wmf_sig_mask,
4844         },
4845         NULL,
4846         decode_image_wmf,
4847         NULL
4848     },
4849     {
4850         { /* PNG */
4851             /* Clsid */              { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4852             /* FormatID */           { 0xb96b3cafU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4853             /* CodecName */          png_codecname,
4854             /* DllName */            NULL,
4855             /* FormatDescription */  png_format,
4856             /* FilenameExtension */  png_extension,
4857             /* MimeType */           png_mimetype,
4858             /* Flags */              ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4859             /* Version */            1,
4860             /* SigCount */           1,
4861             /* SigSize */            8,
4862             /* SigPattern */         png_sig_pattern,
4863             /* SigMask */            png_sig_mask,
4864         },
4865         encode_image_png,
4866         decode_image_png,
4867         select_frame_wic
4868     },
4869     {
4870         { /* ICO */
4871             /* Clsid */              { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
4872             /* FormatID */           { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
4873             /* CodecName */          ico_codecname,
4874             /* DllName */            NULL,
4875             /* FormatDescription */  ico_format,
4876             /* FilenameExtension */  ico_extension,
4877             /* MimeType */           ico_mimetype,
4878             /* Flags */              ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
4879             /* Version */            1,
4880             /* SigCount */           1,
4881             /* SigSize */            4,
4882             /* SigPattern */         ico_sig_pattern,
4883             /* SigMask */            ico_sig_mask,
4884         },
4885         NULL,
4886         decode_image_icon,
4887         select_frame_wic
4888     },
4889 };
4890
4891 /*****************************************************************************
4892  * GdipGetImageDecodersSize [GDIPLUS.@]
4893  */
4894 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
4895 {
4896     int decoder_count=0;
4897     int i;
4898     TRACE("%p %p\n", numDecoders, size);
4899
4900     if (!numDecoders || !size)
4901         return InvalidParameter;
4902
4903     for (i=0; i<NUM_CODECS; i++)
4904     {
4905         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
4906             decoder_count++;
4907     }
4908
4909     *numDecoders = decoder_count;
4910     *size = decoder_count * sizeof(ImageCodecInfo);
4911
4912     return Ok;
4913 }
4914
4915 /*****************************************************************************
4916  * GdipGetImageDecoders [GDIPLUS.@]
4917  */
4918 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
4919 {
4920     int i, decoder_count=0;
4921     TRACE("%u %u %p\n", numDecoders, size, decoders);
4922
4923     if (!decoders ||
4924         size != numDecoders * sizeof(ImageCodecInfo))
4925         return GenericError;
4926
4927     for (i=0; i<NUM_CODECS; i++)
4928     {
4929         if (codecs[i].info.Flags & ImageCodecFlagsDecoder)
4930         {
4931             if (decoder_count == numDecoders) return GenericError;
4932             memcpy(&decoders[decoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4933             decoder_count++;
4934         }
4935     }
4936
4937     if (decoder_count < numDecoders) return GenericError;
4938
4939     return Ok;
4940 }
4941
4942 /*****************************************************************************
4943  * GdipGetImageEncodersSize [GDIPLUS.@]
4944  */
4945 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
4946 {
4947     int encoder_count=0;
4948     int i;
4949     TRACE("%p %p\n", numEncoders, size);
4950
4951     if (!numEncoders || !size)
4952         return InvalidParameter;
4953
4954     for (i=0; i<NUM_CODECS; i++)
4955     {
4956         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4957             encoder_count++;
4958     }
4959
4960     *numEncoders = encoder_count;
4961     *size = encoder_count * sizeof(ImageCodecInfo);
4962
4963     return Ok;
4964 }
4965
4966 /*****************************************************************************
4967  * GdipGetImageEncoders [GDIPLUS.@]
4968  */
4969 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
4970 {
4971     int i, encoder_count=0;
4972     TRACE("%u %u %p\n", numEncoders, size, encoders);
4973
4974     if (!encoders ||
4975         size != numEncoders * sizeof(ImageCodecInfo))
4976         return GenericError;
4977
4978     for (i=0; i<NUM_CODECS; i++)
4979     {
4980         if (codecs[i].info.Flags & ImageCodecFlagsEncoder)
4981         {
4982             if (encoder_count == numEncoders) return GenericError;
4983             memcpy(&encoders[encoder_count], &codecs[i].info, sizeof(ImageCodecInfo));
4984             encoder_count++;
4985         }
4986     }
4987
4988     if (encoder_count < numEncoders) return GenericError;
4989
4990     return Ok;
4991 }
4992
4993 GpStatus WINGDIPAPI GdipGetEncoderParameterListSize(GpImage *image,
4994     GDIPCONST CLSID* clsidEncoder, UINT *size)
4995 {
4996     static int calls;
4997
4998     TRACE("(%p,%s,%p)\n", image, debugstr_guid(clsidEncoder), size);
4999
5000     if(!(calls++))
5001         FIXME("not implemented\n");
5002
5003     *size = 0;
5004
5005     return NotImplemented;
5006 }
5007
5008 static PixelFormat get_16bpp_format(HBITMAP hbm)
5009 {
5010     BITMAPV4HEADER bmh;
5011     HDC hdc;
5012     PixelFormat result;
5013
5014     hdc = CreateCompatibleDC(NULL);
5015
5016     memset(&bmh, 0, sizeof(bmh));
5017     bmh.bV4Size = sizeof(bmh);
5018     bmh.bV4Width = 1;
5019     bmh.bV4Height = 1;
5020     bmh.bV4V4Compression = BI_BITFIELDS;
5021     bmh.bV4BitCount = 16;
5022
5023     GetDIBits(hdc, hbm, 0, 0, NULL, (BITMAPINFO*)&bmh, DIB_RGB_COLORS);
5024
5025     if (bmh.bV4RedMask == 0x7c00 &&
5026         bmh.bV4GreenMask == 0x3e0 &&
5027         bmh.bV4BlueMask == 0x1f)
5028     {
5029         result = PixelFormat16bppRGB555;
5030     }
5031     else if (bmh.bV4RedMask == 0xf800 &&
5032         bmh.bV4GreenMask == 0x7e0 &&
5033         bmh.bV4BlueMask == 0x1f)
5034     {
5035         result = PixelFormat16bppRGB565;
5036     }
5037     else
5038     {
5039         FIXME("unrecognized bitfields %x,%x,%x\n", bmh.bV4RedMask,
5040             bmh.bV4GreenMask, bmh.bV4BlueMask);
5041         result = PixelFormatUndefined;
5042     }
5043
5044     DeleteDC(hdc);
5045
5046     return result;
5047 }
5048
5049 /*****************************************************************************
5050  * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
5051  */
5052 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
5053 {
5054     BITMAP bm;
5055     GpStatus retval;
5056     PixelFormat format;
5057     BitmapData lockeddata;
5058
5059     TRACE("%p %p %p\n", hbm, hpal, bitmap);
5060
5061     if(!hbm || !bitmap)
5062         return InvalidParameter;
5063
5064     if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
5065             return InvalidParameter;
5066
5067     /* TODO: Figure out the correct format for 16, 32, 64 bpp */
5068     switch(bm.bmBitsPixel) {
5069         case 1:
5070             format = PixelFormat1bppIndexed;
5071             break;
5072         case 4:
5073             format = PixelFormat4bppIndexed;
5074             break;
5075         case 8:
5076             format = PixelFormat8bppIndexed;
5077             break;
5078         case 16:
5079             format = get_16bpp_format(hbm);
5080             if (format == PixelFormatUndefined)
5081                 return InvalidParameter;
5082             break;
5083         case 24:
5084             format = PixelFormat24bppRGB;
5085             break;
5086         case 32:
5087             format = PixelFormat32bppRGB;
5088             break;
5089         case 48:
5090             format = PixelFormat48bppRGB;
5091             break;
5092         default:
5093             FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
5094             return InvalidParameter;
5095     }
5096
5097     retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, 0,
5098         format, NULL, bitmap);
5099
5100     if (retval == Ok)
5101     {
5102         retval = GdipBitmapLockBits(*bitmap, NULL, ImageLockModeWrite,
5103             format, &lockeddata);
5104         if (retval == Ok)
5105         {
5106             HDC hdc;
5107             char bmibuf[FIELD_OFFSET(BITMAPINFO, bmiColors[256])];
5108             BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
5109             INT src_height;
5110
5111             hdc = CreateCompatibleDC(NULL);
5112
5113             pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
5114             pbmi->bmiHeader.biBitCount = 0;
5115
5116             GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
5117
5118             src_height = abs(pbmi->bmiHeader.biHeight);
5119             pbmi->bmiHeader.biHeight = -src_height;
5120
5121             GetDIBits(hdc, hbm, 0, src_height, lockeddata.Scan0, pbmi, DIB_RGB_COLORS);
5122
5123             DeleteDC(hdc);
5124
5125             GdipBitmapUnlockBits(*bitmap, &lockeddata);
5126         }
5127
5128         if (retval == Ok && hpal)
5129         {
5130             PALETTEENTRY entry[256];
5131             ColorPalette *palette=NULL;
5132             int i, num_palette_entries;
5133
5134             num_palette_entries = GetPaletteEntries(hpal, 0, 256, entry);
5135             if (!num_palette_entries)
5136                 retval = GenericError;
5137
5138             palette = heap_alloc_zero(sizeof(ColorPalette) + sizeof(ARGB) * (num_palette_entries-1));
5139             if (!palette)
5140                 retval = OutOfMemory;
5141
5142             if (retval == Ok)
5143             {
5144                 palette->Flags = 0;
5145                 palette->Count = num_palette_entries;
5146
5147                 for (i=0; i<num_palette_entries; i++)
5148                 {
5149                     palette->Entries[i] = 0xff000000 | entry[i].peRed << 16 |
5150                                           entry[i].peGreen << 8 | entry[i].peBlue;
5151                 }
5152
5153                 retval = GdipSetImagePalette(&(*bitmap)->image, palette);
5154             }
5155
5156             heap_free(palette);
5157         }
5158
5159         if (retval != Ok)
5160         {
5161             GdipDisposeImage(&(*bitmap)->image);
5162             *bitmap = NULL;
5163         }
5164     }
5165
5166     return retval;
5167 }
5168
5169 /*****************************************************************************
5170  * GdipCreateEffect [GDIPLUS.@]
5171  */
5172 GpStatus WINGDIPAPI GdipCreateEffect(const GUID guid, CGpEffect **effect)
5173 {
5174     FIXME("(%s, %p): stub\n", debugstr_guid(&guid), effect);
5175
5176     if(!effect)
5177         return InvalidParameter;
5178
5179     *effect = NULL;
5180
5181     return NotImplemented;
5182 }
5183
5184 /*****************************************************************************
5185  * GdipDeleteEffect [GDIPLUS.@]
5186  */
5187 GpStatus WINGDIPAPI GdipDeleteEffect(CGpEffect *effect)
5188 {
5189     FIXME("(%p): stub\n", effect);
5190     /* note: According to Jose Roca's GDI+ Docs, this is not implemented
5191      * in Windows's gdiplus */
5192     return NotImplemented;
5193 }
5194
5195 /*****************************************************************************
5196  * GdipSetEffectParameters [GDIPLUS.@]
5197  */
5198 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
5199     const VOID *params, const UINT size)
5200 {
5201     static int calls;
5202
5203     TRACE("(%p,%p,%u)\n", effect, params, size);
5204
5205     if(!(calls++))
5206         FIXME("not implemented\n");
5207
5208     return NotImplemented;
5209 }
5210
5211 /*****************************************************************************
5212  * GdipGetImageFlags [GDIPLUS.@]
5213  */
5214 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
5215 {
5216     TRACE("%p %p\n", image, flags);
5217
5218     if(!image || !flags)
5219         return InvalidParameter;
5220
5221     *flags = image->flags;
5222
5223     return Ok;
5224 }
5225
5226 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
5227 {
5228     TRACE("(%d, %p)\n", control, param);
5229
5230     switch(control){
5231         case TestControlForceBilinear:
5232             if(param)
5233                 FIXME("TestControlForceBilinear not handled\n");
5234             break;
5235         case TestControlNoICM:
5236             if(param)
5237                 FIXME("TestControlNoICM not handled\n");
5238             break;
5239         case TestControlGetBuildNumber:
5240             *((DWORD*)param) = 3102;
5241             break;
5242     }
5243
5244     return Ok;
5245 }
5246
5247 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
5248 {
5249     TRACE("%p\n", image);
5250
5251     return Ok;
5252 }
5253
5254 /*****************************************************************************
5255  * GdipGetImageThumbnail [GDIPLUS.@]
5256  */
5257 GpStatus WINGDIPAPI GdipGetImageThumbnail(GpImage *image, UINT width, UINT height,
5258                             GpImage **ret_image, GetThumbnailImageAbort cb,
5259                             VOID * cb_data)
5260 {
5261     GpStatus stat;
5262     GpGraphics *graphics;
5263     UINT srcwidth, srcheight;
5264
5265     TRACE("(%p %u %u %p %p %p)\n",
5266         image, width, height, ret_image, cb, cb_data);
5267
5268     if (!image || !ret_image)
5269         return InvalidParameter;
5270
5271     if (!width) width = 120;
5272     if (!height) height = 120;
5273
5274     GdipGetImageWidth(image, &srcwidth);
5275     GdipGetImageHeight(image, &srcheight);
5276
5277     stat = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat32bppPARGB,
5278         NULL, (GpBitmap**)ret_image);
5279
5280     if (stat == Ok)
5281     {
5282         stat = GdipGetImageGraphicsContext(*ret_image, &graphics);
5283
5284         if (stat == Ok)
5285         {
5286             stat = GdipDrawImageRectRectI(graphics, image,
5287                 0, 0, width, height, 0, 0, srcwidth, srcheight, UnitPixel,
5288                 NULL, NULL, NULL);
5289
5290             GdipDeleteGraphics(graphics);
5291         }
5292
5293         if (stat != Ok)
5294         {
5295             GdipDisposeImage(*ret_image);
5296             *ret_image = NULL;
5297         }
5298     }
5299
5300     return stat;
5301 }
5302
5303 /*****************************************************************************
5304  * GdipImageRotateFlip [GDIPLUS.@]
5305  */
5306 GpStatus WINGDIPAPI GdipImageRotateFlip(GpImage *image, RotateFlipType type)
5307 {
5308     GpBitmap *new_bitmap;
5309     GpBitmap *bitmap;
5310     int bpp, bytesperpixel;
5311     BOOL rotate_90, flip_x, flip_y;
5312     int src_x_offset, src_y_offset;
5313     LPBYTE src_origin;
5314     UINT x, y, width, height;
5315     BitmapData src_lock, dst_lock;
5316     GpStatus stat;
5317     BOOL unlock;
5318
5319     TRACE("(%p, %u)\n", image, type);
5320
5321     if (!image)
5322         return InvalidParameter;
5323     if (!image_lock(image, &unlock))
5324         return ObjectBusy;
5325
5326     rotate_90 = type&1;
5327     flip_x = (type&6) == 2 || (type&6) == 4;
5328     flip_y = (type&3) == 1 || (type&3) == 2;
5329
5330     if (image->type != ImageTypeBitmap)
5331     {
5332         FIXME("Not implemented for type %i\n", image->type);
5333         image_unlock(image, unlock);
5334         return NotImplemented;
5335     }
5336
5337     bitmap = (GpBitmap*)image;
5338     bpp = PIXELFORMATBPP(bitmap->format);
5339
5340     if (bpp < 8)
5341     {
5342         FIXME("Not implemented for %i bit images\n", bpp);
5343         image_unlock(image, unlock);
5344         return NotImplemented;
5345     }
5346
5347     if (rotate_90)
5348     {
5349         width = bitmap->height;
5350         height = bitmap->width;
5351     }
5352     else
5353     {
5354         width = bitmap->width;
5355         height = bitmap->height;
5356     }
5357
5358     bytesperpixel = bpp/8;
5359
5360     stat = GdipCreateBitmapFromScan0(width, height, 0, bitmap->format, NULL, &new_bitmap);
5361
5362     if (stat != Ok)
5363     {
5364         image_unlock(image, unlock);
5365         return stat;
5366     }
5367
5368     stat = GdipBitmapLockBits(bitmap, NULL, ImageLockModeRead, bitmap->format, &src_lock);
5369
5370     if (stat == Ok)
5371     {
5372         stat = GdipBitmapLockBits(new_bitmap, NULL, ImageLockModeWrite, bitmap->format, &dst_lock);
5373
5374         if (stat == Ok)
5375         {
5376             LPBYTE src_row, src_pixel;
5377             LPBYTE dst_row, dst_pixel;
5378
5379             src_origin = src_lock.Scan0;
5380             if (flip_x) src_origin += bytesperpixel * (bitmap->width - 1);
5381             if (flip_y) src_origin += src_lock.Stride * (bitmap->height - 1);
5382
5383             if (rotate_90)
5384             {
5385                 if (flip_y) src_x_offset = -src_lock.Stride;
5386                 else src_x_offset = src_lock.Stride;
5387                 if (flip_x) src_y_offset = -bytesperpixel;
5388                 else src_y_offset = bytesperpixel;
5389             }
5390             else
5391             {
5392                 if (flip_x) src_x_offset = -bytesperpixel;
5393                 else src_x_offset = bytesperpixel;
5394                 if (flip_y) src_y_offset = -src_lock.Stride;
5395                 else src_y_offset = src_lock.Stride;
5396             }
5397
5398             src_row = src_origin;
5399             dst_row = dst_lock.Scan0;
5400             for (y=0; y<height; y++)
5401             {
5402                 src_pixel = src_row;
5403                 dst_pixel = dst_row;
5404                 for (x=0; x<width; x++)
5405                 {
5406                     /* FIXME: This could probably be faster without memcpy. */
5407                     memcpy(dst_pixel, src_pixel, bytesperpixel);
5408                     dst_pixel += bytesperpixel;
5409                     src_pixel += src_x_offset;
5410                 }
5411                 src_row += src_y_offset;
5412                 dst_row += dst_lock.Stride;
5413             }
5414
5415             GdipBitmapUnlockBits(new_bitmap, &dst_lock);
5416         }
5417
5418         GdipBitmapUnlockBits(bitmap, &src_lock);
5419     }
5420
5421     if (stat == Ok)
5422         move_bitmap(bitmap, new_bitmap, FALSE);
5423     else
5424         GdipDisposeImage(&new_bitmap->image);
5425
5426     image_unlock(image, unlock);
5427     return stat;
5428 }
5429
5430 /*****************************************************************************
5431  * GdipImageSetAbort [GDIPLUS.@]
5432  */
5433 GpStatus WINGDIPAPI GdipImageSetAbort(GpImage *image, GdiplusAbort *pabort)
5434 {
5435     TRACE("(%p, %p)\n", image, pabort);
5436
5437     if (!image)
5438         return InvalidParameter;
5439
5440     if (pabort)
5441         FIXME("Abort callback is not supported.\n");
5442
5443     return Ok;
5444 }
5445
5446 /*****************************************************************************
5447  * GdipBitmapConvertFormat [GDIPLUS.@]
5448  */
5449 GpStatus WINGDIPAPI GdipBitmapConvertFormat(GpBitmap *bitmap, PixelFormat format, DitherType dithertype,
5450     PaletteType palettetype, ColorPalette *palette, REAL alphathreshold)
5451 {
5452     FIXME("(%p, 0x%08x, %d, %d, %p, %f): stub\n", bitmap, format, dithertype, palettetype, palette, alphathreshold);
5453     return NotImplemented;
5454 }
5455
5456 static void set_histogram_point_argb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5457 {
5458     ch0[ color >> 24        ]++;
5459     ch1[(color >> 16) & 0xff]++;
5460     ch2[(color >>  8) & 0xff]++;
5461     ch3[ color        & 0xff]++;
5462 }
5463
5464 static void set_histogram_point_pargb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5465 {
5466     BYTE alpha = color >> 24;
5467
5468     ch0[alpha]++;
5469     ch1[(((color >> 16) & 0xff) * alpha) / 0xff]++;
5470     ch2[(((color >>  8) & 0xff) * alpha) / 0xff]++;
5471     ch3[(( color        & 0xff) * alpha) / 0xff]++;
5472 }
5473
5474 static void set_histogram_point_rgb(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5475 {
5476     ch0[(color >> 16) & 0xff]++;
5477     ch1[(color >>  8) & 0xff]++;
5478     ch2[ color        & 0xff]++;
5479 }
5480
5481 static void set_histogram_point_gray(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5482 {
5483     ch0[(76 * ((color >> 16) & 0xff) + 150 * ((color >> 8) & 0xff) + 29 * (color & 0xff)) / 0xff]++;
5484 }
5485
5486 static void set_histogram_point_b(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5487 {
5488     ch0[color & 0xff]++;
5489 }
5490
5491 static void set_histogram_point_g(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5492 {
5493     ch0[(color >> 8) & 0xff]++;
5494 }
5495
5496 static void set_histogram_point_r(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5497 {
5498     ch0[(color >> 16) & 0xff]++;
5499 }
5500
5501 static void set_histogram_point_a(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5502 {
5503     ch0[(color >> 24) & 0xff]++;
5504 }
5505
5506 /*****************************************************************************
5507  * GdipBitmapGetHistogram [GDIPLUS.@]
5508  */
5509 GpStatus WINGDIPAPI GdipBitmapGetHistogram(GpBitmap *bitmap, HistogramFormat format, UINT num_of_entries,
5510     UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3)
5511 {
5512     static void (* const set_histogram_point[])(ARGB color, UINT *ch0, UINT *ch1, UINT *ch2, UINT *ch3) =
5513     {
5514         set_histogram_point_argb,
5515         set_histogram_point_pargb,
5516         set_histogram_point_rgb,
5517         set_histogram_point_gray,
5518         set_histogram_point_b,
5519         set_histogram_point_g,
5520         set_histogram_point_r,
5521         set_histogram_point_a,
5522     };
5523     UINT width, height, x, y;
5524
5525     TRACE("(%p, %d, %u, %p, %p, %p, %p)\n", bitmap, format, num_of_entries,
5526         ch0, ch1, ch2, ch3);
5527
5528     if (!bitmap || num_of_entries != 256)
5529         return InvalidParameter;
5530
5531     /* Make sure passed channel pointers match requested format */
5532     switch (format)
5533     {
5534     case HistogramFormatARGB:
5535     case HistogramFormatPARGB:
5536         if (!ch0 || !ch1 || !ch2 || !ch3)
5537             return InvalidParameter;
5538         memset(ch0, 0, num_of_entries * sizeof(UINT));
5539         memset(ch1, 0, num_of_entries * sizeof(UINT));
5540         memset(ch2, 0, num_of_entries * sizeof(UINT));
5541         memset(ch3, 0, num_of_entries * sizeof(UINT));
5542         break;
5543     case HistogramFormatRGB:
5544         if (!ch0 || !ch1 || !ch2 || ch3)
5545             return InvalidParameter;
5546         memset(ch0, 0, num_of_entries * sizeof(UINT));
5547         memset(ch1, 0, num_of_entries * sizeof(UINT));
5548         memset(ch2, 0, num_of_entries * sizeof(UINT));
5549         break;
5550     case HistogramFormatGray:
5551     case HistogramFormatB:
5552     case HistogramFormatG:
5553     case HistogramFormatR:
5554     case HistogramFormatA:
5555         if (!ch0 || ch1 || ch2 || ch3)
5556             return InvalidParameter;
5557         memset(ch0, 0, num_of_entries * sizeof(UINT));
5558         break;
5559     default:
5560         WARN("Invalid histogram format requested, %d\n", format);
5561         return InvalidParameter;
5562     }
5563
5564     GdipGetImageWidth(&bitmap->image, &width);
5565     GdipGetImageHeight(&bitmap->image, &height);
5566
5567     for (y = 0; y < height; y++)
5568         for (x = 0; x < width; x++)
5569         {
5570             ARGB color;
5571
5572             GdipBitmapGetPixel(bitmap, x, y, &color);
5573             set_histogram_point[format](color, ch0, ch1, ch2, ch3);
5574         }
5575
5576     return Ok;
5577 }
5578
5579 /*****************************************************************************
5580  * GdipBitmapGetHistogramSize [GDIPLUS.@]
5581  */
5582 GpStatus WINGDIPAPI GdipBitmapGetHistogramSize(HistogramFormat format, UINT *num_of_entries)
5583 {
5584     TRACE("(%d, %p)\n", format, num_of_entries);
5585
5586     if (!num_of_entries)
5587         return InvalidParameter;
5588
5589     *num_of_entries = 256;
5590     return Ok;
5591 }